<?php
/**
 * PHPExcel
 *
 * Copyright (c) 2006 - 2011 PHPExcel
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * @category   PHPExcel
 * @package    PHPExcel_Reader_Excel5
 * @copyright  Copyright (c) 2006 - 2011 PHPExcel (http://www.codeplex.com/PHPExcel)
 * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
 * @version    1.7.6, 2011-02-27
 */

// Original file header of ParseXL (used as the base for this class):
// --------------------------------------------------------------------------------
// Adapted from Excel_Spreadsheet_Reader developed by users bizon153,
// trex005, and mmp11 (SourceForge.net)
// http://sourceforge.net/projects/phpexcelreader/
// Primary changes made by canyoncasa (dvc) for ParseXL 1.00 ...
//     Modelled moreso after Perl Excel Parse/Write modules
//     Added Parse_Excel_Spreadsheet object
//         Reads a whole worksheet or tab as row,column array or as
//         associated hash of indexed rows and named column fields
//     Added variables for worksheet (tab) indexes and names
//     Added an object call for loading individual woorksheets
//     Changed default indexing defaults to 0 based arrays
//     Fixed date/time and percent formats
//     Includes patches found at SourceForge...
//         unicode patch by nobody
//         unpack("d") machine depedency patch by matchy
//         boundsheet utf16 patch by bjaenichen
//     Renamed functions for shorter names
//     General code cleanup and rigor, including <80 column width
//     Included a testcase Excel file and PHP example calls
//     Code works for PHP 5.x

// Primary changes made by canyoncasa (dvc) for ParseXL 1.10 ...
// http://sourceforge.net/tracker/index.php?func=detail&aid=1466964&group_id=99160&atid=623334
//     Decoding of formula conditions, results, and tokens.
//     Support for user-defined named cells added as an array "namedcells"
//         Patch code for user-defined named cells supports single cells only.
//         NOTE: this patch only works for BIFF8 as BIFF5-7 use a different
//         external sheet reference structure


/** PHPExcel root directory */
if (!defined('PHPEXCEL_ROOT')) {
    /**
     * @ignore
     */
    define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
    require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
}

/**
 *    PHPExcel_Reader_Excel5
 *
 *    This class uses {@link http://sourceforge.net/projects/phpexcelreader/parseXL}
 *
 *    @category    PHPExcel
 *    @package    PHPExcel_Reader_Excel5
 *    @copyright    Copyright (c) 2006 - 2011 PHPExcel (http://www.codeplex.com/PHPExcel)
 */
class PHPExcel_Reader_Excel5 implements PHPExcel_Reader_IReader
{
    // ParseXL definitions
    const XLS_BIFF8                        = 0x0600;
    const XLS_BIFF7                        = 0x0500;
    const XLS_WorkbookGlobals            = 0x0005;
    const XLS_Worksheet                    = 0x0010;

    // record identifiers
    const XLS_Type_FORMULA                = 0x0006;
    const XLS_Type_EOF                    = 0x000a;
    const XLS_Type_PROTECT                = 0x0012;
    const XLS_Type_OBJECTPROTECT        = 0x0063;
    const XLS_Type_SCENPROTECT            = 0x00dd;
    const XLS_Type_PASSWORD                = 0x0013;
    const XLS_Type_HEADER                = 0x0014;
    const XLS_Type_FOOTER                = 0x0015;
    const XLS_Type_EXTERNSHEET            = 0x0017;
    const XLS_Type_DEFINEDNAME            = 0x0018;
    const XLS_Type_VERTICALPAGEBREAKS    = 0x001a;
    const XLS_Type_HORIZONTALPAGEBREAKS    = 0x001b;
    const XLS_Type_NOTE                    = 0x001c;
    const XLS_Type_SELECTION            = 0x001d;
    const XLS_Type_DATEMODE                = 0x0022;
    const XLS_Type_EXTERNNAME            = 0x0023;
    const XLS_Type_LEFTMARGIN            = 0x0026;
    const XLS_Type_RIGHTMARGIN            = 0x0027;
    const XLS_Type_TOPMARGIN            = 0x0028;
    const XLS_Type_BOTTOMMARGIN            = 0x0029;
    const XLS_Type_PRINTGRIDLINES        = 0x002b;
    const XLS_Type_FILEPASS                = 0x002f;
    const XLS_Type_FONT                    = 0x0031;
    const XLS_Type_CONTINUE                = 0x003c;
    const XLS_Type_PANE                    = 0x0041;
    const XLS_Type_CODEPAGE                = 0x0042;
    const XLS_Type_DEFCOLWIDTH             = 0x0055;
    const XLS_Type_OBJ                    = 0x005d;
    const XLS_Type_COLINFO                = 0x007d;
    const XLS_Type_IMDATA                = 0x007f;
    const XLS_Type_SHEETPR                = 0x0081;
    const XLS_Type_HCENTER                = 0x0083;
    const XLS_Type_VCENTER                = 0x0084;
    const XLS_Type_SHEET                = 0x0085;
    const XLS_Type_PALETTE                = 0x0092;
    const XLS_Type_SCL                    = 0x00a0;
    const XLS_Type_PAGESETUP            = 0x00a1;
    const XLS_Type_MULRK                = 0x00bd;
    const XLS_Type_MULBLANK                = 0x00be;
    const XLS_Type_DBCELL                = 0x00d7;
    const XLS_Type_XF                    = 0x00e0;
    const XLS_Type_MERGEDCELLS            = 0x00e5;
    const XLS_Type_MSODRAWINGGROUP        = 0x00eb;
    const XLS_Type_MSODRAWING            = 0x00ec;
    const XLS_Type_SST                    = 0x00fc;
    const XLS_Type_LABELSST                = 0x00fd;
    const XLS_Type_EXTSST                = 0x00ff;
    const XLS_Type_EXTERNALBOOK            = 0x01ae;
    const XLS_Type_DATAVALIDATIONS        = 0x01b2;
    const XLS_Type_TXO                    = 0x01b6;
    const XLS_Type_HYPERLINK            = 0x01b8;
    const XLS_Type_DATAVALIDATION        = 0x01be;
    const XLS_Type_DIMENSION            = 0x0200;
    const XLS_Type_BLANK                = 0x0201;
    const XLS_Type_NUMBER                = 0x0203;
    const XLS_Type_LABEL                = 0x0204;
    const XLS_Type_BOOLERR                = 0x0205;
    const XLS_Type_STRING                = 0x0207;
    const XLS_Type_ROW                    = 0x0208;
    const XLS_Type_INDEX                = 0x020b;
    const XLS_Type_ARRAY                = 0x0221;
    const XLS_Type_DEFAULTROWHEIGHT     = 0x0225;
    const XLS_Type_WINDOW2                = 0x023e;
    const XLS_Type_RK                    = 0x027e;
    const XLS_Type_STYLE                = 0x0293;
    const XLS_Type_FORMAT                = 0x041e;
    const XLS_Type_SHAREDFMLA            = 0x04bc;
    const XLS_Type_BOF                    = 0x0809;
    const XLS_Type_SHEETPROTECTION        = 0x0867;
    const XLS_Type_RANGEPROTECTION        = 0x0868;
    const XLS_Type_SHEETLAYOUT            = 0x0862;
    const XLS_Type_XFEXT                = 0x087d;
    const XLS_Type_UNKNOWN                = 0xffff;

    /**
     *    Read data only?
     *    Identifies whether the Reader should only read data values for cells, and ignore any formatting information;
     *        or whether it should read both data and formatting
     *
     *    @var    boolean
     */
    private $_readDataOnly = false;

    /**
     *    Restrict which sheets should be loaded?
     *    This property holds an array of worksheet names to be loaded. If null, then all worksheets will be loaded.
     *
     *    @var    array of string
     */
    private $_loadSheetsOnly = null;

    /**
     * PHPExcel_Reader_IReadFilter instance
     *
     * @var PHPExcel_Reader_IReadFilter
     */
    private $_readFilter = null;

    /**
     * Summary Information stream data.
     *
     * @var string
     */
    private $_summaryInformation;

    /**
     * Extended Summary Information stream data.
     *
     * @var string
     */
    private $_documentSummaryInformation;

    /**
     * User-Defined Properties stream data.
     *
     * @var string
     */
    private $_userDefinedProperties;

    /**
     * Workbook stream data. (Includes workbook globals substream as well as sheet substreams)
     *
     * @var string
     */
    private $_data;

    /**
     * Size in bytes of $this->_data
     *
     * @var int
     */
    private $_dataSize;

    /**
     * Current position in stream
     *
     * @var integer
     */
    private $_pos;

    /**
     * Workbook to be returned by the reader.
     *
     * @var PHPExcel
     */
    private $_phpExcel;

    /**
     * Worksheet that is currently being built by the reader.
     *
     * @var PHPExcel_Worksheet
     */
    private $_phpSheet;

    /**
     * BIFF version
     *
     * @var int
     */
    private $_version;

    /**
     * Codepage set in the Excel file being read. Only important for BIFF5 (Excel 5.0 - Excel 95)
     * For BIFF8 (Excel 97 - Excel 2003) this will always have the value 'UTF-16LE'
     *
     * @var string
     */
    private $_codepage;

    /**
     * Shared formats
     *
     * @var array
     */
    private $_formats;

    /**
     * Shared fonts
     *
     * @var array
     */
    private $_objFonts;

    /**
     * Color palette
     *
     * @var array
     */
    private $_palette;

    /**
     * Worksheets
     *
     * @var array
     */
    private $_sheets;

    /**
     * External books
     *
     * @var array
     */
    private $_externalBooks;

    /**
     * REF structures. Only applies to BIFF8.
     *
     * @var array
     */
    private $_ref;

    /**
     * External names
     *
     * @var array
     */
    private $_externalNames;

    /**
     * Defined names
     *
     * @var array
     */
    private $_definedname;

    /**
     * Shared strings. Only applies to BIFF8.
     *
     * @var array
     */
    private $_sst;

    /**
     * Panes are frozen? (in sheet currently being read). See WINDOW2 record.
     *
     * @var boolean
     */
    private $_frozen;

    /**
     * Fit printout to number of pages? (in sheet currently being read). See SHEETPR record.
     *
     * @var boolean
     */
    private $_isFitToPages;

    /**
     * Objects. One OBJ record contributes with one entry.
     *
     * @var array
     */
    private $_objs;

    /**
     * Text Objects. One TXO record corresponds with one entry.
     *
     * @var array
     */
    private $_textObjects;

    /**
     * Cell Annotations (BIFF8)
     *
     * @var array
     */
    private $_cellNotes;

    /**
     * The combined MSODRAWINGGROUP data
     *
     * @var string
     */
    private $_drawingGroupData;

    /**
     * The combined MSODRAWING data (per sheet)
     *
     * @var string
     */
    private $_drawingData;

    /**
     * Keep track of XF index
     *
     * @var int
     */
    private $_xfIndex;

    /**
     * Mapping of XF index (that is a cell XF) to final index in cellXf collection
     *
     * @var array
     */
    private $_mapCellXfIndex;

    /**
     * Mapping of XF index (that is a style XF) to final index in cellStyleXf collection
     *
     * @var array
     */
    private $_mapCellStyleXfIndex;

    /**
     * The shared formulas in a sheet. One SHAREDFMLA record contributes with one value.
     *
     * @var array
     */
    private $_sharedFormulas;

    /**
     * The shared formula parts in a sheet. One FORMULA record contributes with one value if it
     * refers to a shared formula.
     *
     * @var array
     */
    private $_sharedFormulaParts;


    /**
     *    Read data only?
     *        If this is true, then the Reader will only read data values for cells, it will not read any formatting information.
     *        If false (the default) it will read data and formatting.
     *
     *    @return    boolean
     */
    public function getReadDataOnly()
    {
        return $this->_readDataOnly;
    }

    /**
     *    Set read data only
     *        Set to true, to advise the Reader only to read data values for cells, and to ignore any formatting information.
     *        Set to false (the default) to advise the Reader to read both data and formatting for cells.
     *
     *    @param    boolean    $pValue
     *
     *    @return    PHPExcel_Reader_Excel5
     */
    public function setReadDataOnly($pValue = false)
    {
        $this->_readDataOnly = $pValue;
        return $this;
    }

    /**
     *    Get which sheets to load
     *        Returns either an array of worksheet names (the list of worksheets that should be loaded), or a null
     *            indicating that all worksheets in the workbook should be loaded.
     *
     *    @return mixed
     */
    public function getLoadSheetsOnly()
    {
        return $this->_loadSheetsOnly;
    }

    /**
     *    Set which sheets to load
     *
     *    @param mixed $value
     *        This should be either an array of worksheet names to be loaded, or a string containing a single worksheet name.
     *        If NULL, then it tells the Reader to read all worksheets in the workbook
     *
     *    @return PHPExcel_Reader_Excel5
     */
    public function setLoadSheetsOnly($value = null)
    {
        $this->_loadSheetsOnly = is_array($value) ?
            $value : array($value);
        return $this;
    }

    /**
     *    Set all sheets to load
     *        Tells the Reader to load all worksheets from the workbook.
     *
     *    @return    PHPExcel_Reader_Excel5
     */
    public function setLoadAllSheets()
    {
        $this->_loadSheetsOnly = null;
        return $this;
    }

    /**
     * Read filter
     *
     * @return PHPExcel_Reader_IReadFilter
     */
    public function getReadFilter() {
        return $this->_readFilter;
    }

    /**
     * Set read filter
     *
     * @param PHPExcel_Reader_IReadFilter $pValue
     * @return PHPExcel_Reader_Excel5
     */
    public function setReadFilter(PHPExcel_Reader_IReadFilter $pValue) {
        $this->_readFilter = $pValue;
        return $this;
    }

    /**
     * Create a new PHPExcel_Reader_Excel5 instance
     */
    public function __construct() {
        $this->_readFilter = new PHPExcel_Reader_DefaultReadFilter();
    }

    /**
     * Can the current PHPExcel_Reader_IReader read the file?
     *
     * @param     string         $pFileName
     * @return     boolean
     */
    public function canRead($pFilename)
    {
        // Check if file exists
        if (!file_exists($pFilename)) {
            throw new Exception("Could not open " . $pFilename . " for reading! File does not exist.");
        }

        try {
            // Use ParseXL for the hard work.
            $ole = new PHPExcel_Shared_OLERead();

            // get excel data
            $res = $ole->read($pFilename);
            return true;

        } catch (Exception $e) {
            return false;
        }
    }

    /**
     * Reads names of the worksheets from a file, without parsing the whole file to a PHPExcel object
     *
     * @param     string         $pFilename
     * @throws     Exception
     */
    public function listWorksheetNames($pFilename)
    {
        // Check if file exists
        if (!file_exists($pFilename)) {
            throw new Exception("Could not open " . $pFilename . " for reading! File does not exist.");
        }

        $worksheetNames = array();

        // Read the OLE file
        $this->_loadOLE($pFilename);

        // total byte size of Excel data (workbook global substream + sheet substreams)
        $this->_dataSize = strlen($this->_data);

        $this->_pos        = 0;
        $this->_sheets    = array();

        // Parse Workbook Global Substream
        while ($this->_pos < $this->_dataSize) {
            $code = self::_GetInt2d($this->_data, $this->_pos);

            switch ($code) {
                case self::XLS_Type_BOF:    $this->_readBof();        break;
                case self::XLS_Type_SHEET:    $this->_readSheet();    break;
                case self::XLS_Type_EOF:    $this->_readDefault();    break 2;
                default:                    $this->_readDefault();    break;
            }
        }

        foreach ($this->_sheets as $sheet) {
            if ($sheet['sheetType'] != 0x00) {
                // 0x00: Worksheet, 0x02: Chart, 0x06: Visual Basic module
                continue;
            }

            $worksheetNames[] = $sheet['name'];
        }

        return $worksheetNames;
    }


    /**
     * Loads PHPExcel from file
     *
     * @param     string         $pFilename
     * @return     PHPExcel
     * @throws     Exception
     */
    public function load($pFilename)
    {
        // Read the OLE file
        $this->_loadOLE($pFilename);

        // Initialisations
        $this->_phpExcel = new PHPExcel;
        $this->_phpExcel->removeSheetByIndex(0); // remove 1st sheet
        if (!$this->_readDataOnly) {
            $this->_phpExcel->removeCellStyleXfByIndex(0); // remove the default style
            $this->_phpExcel->removeCellXfByIndex(0); // remove the default style
        }

        // Read the summary information stream (containing meta data)
        $this->_readSummaryInformation();

        // Read the Additional document summary information stream (containing application-specific meta data)
        $this->_readDocumentSummaryInformation();

        // total byte size of Excel data (workbook global substream + sheet substreams)
        $this->_dataSize = strlen($this->_data);

        // initialize
        $this->_pos                    = 0;
        $this->_codepage            = 'CP1252';
        $this->_formats                = array();
        $this->_objFonts            = array();
        $this->_palette                = array();
        $this->_sheets                = array();
        $this->_externalBooks        = array();
        $this->_ref                    = array();
        $this->_definedname            = array();
        $this->_sst                    = array();
        $this->_drawingGroupData    = '';
        $this->_xfIndex                = '';
        $this->_mapCellXfIndex        = array();
        $this->_mapCellStyleXfIndex    = array();

        // Parse Workbook Global Substream
        while ($this->_pos < $this->_dataSize) {
            $code = self::_GetInt2d($this->_data, $this->_pos);

            switch ($code) {
                case self::XLS_Type_BOF:            $this->_readBof();                break;
                case self::XLS_Type_FILEPASS:        $this->_readFilepass();            break;
                case self::XLS_Type_CODEPAGE:        $this->_readCodepage();            break;
                case self::XLS_Type_DATEMODE:        $this->_readDateMode();            break;
                case self::XLS_Type_FONT:            $this->_readFont();                break;
                case self::XLS_Type_FORMAT:            $this->_readFormat();            break;
                case self::XLS_Type_XF:                $this->_readXf();                break;
                case self::XLS_Type_XFEXT:            $this->_readXfExt();            break;
                case self::XLS_Type_STYLE:            $this->_readStyle();            break;
                case self::XLS_Type_PALETTE:        $this->_readPalette();            break;
                case self::XLS_Type_SHEET:            $this->_readSheet();            break;
                case self::XLS_Type_EXTERNALBOOK:    $this->_readExternalBook();        break;
                case self::XLS_Type_EXTERNNAME:        $this->_readExternName();        break;
                case self::XLS_Type_EXTERNSHEET:    $this->_readExternSheet();        break;
                case self::XLS_Type_DEFINEDNAME:    $this->_readDefinedName();        break;
                case self::XLS_Type_MSODRAWINGGROUP:    $this->_readMsoDrawingGroup();    break;
                case self::XLS_Type_SST:            $this->_readSst();                break;
                case self::XLS_Type_EOF:            $this->_readDefault();            break 2;
                default:                            $this->_readDefault();            break;
            }
        }

        // Resolve indexed colors for font, fill, and border colors
        // Cannot be resolved already in XF record, because PALETTE record comes afterwards
        if (!$this->_readDataOnly) {
            foreach ($this->_objFonts as $objFont) {
                if (isset($objFont->colorIndex)) {
                    $color = self::_readColor($objFont->colorIndex,$this->_palette,$this->_version);
                    $objFont->getColor()->setRGB($color['rgb']);
                }
            }

            foreach ($this->_phpExcel->getCellXfCollection() as $objStyle) {
                // fill start and end color
                $fill = $objStyle->getFill();

                if (isset($fill->startcolorIndex)) {
                    $startColor = self::_readColor($fill->startcolorIndex,$this->_palette,$this->_version);
                    $fill->getStartColor()->setRGB($startColor['rgb']);
                }

                if (isset($fill->endcolorIndex)) {
                    $endColor = self::_readColor($fill->endcolorIndex,$this->_palette,$this->_version);
                    $fill->getEndColor()->setRGB($endColor['rgb']);
                }

                // border colors
                $top      = $objStyle->getBorders()->getTop();
                $right    = $objStyle->getBorders()->getRight();
                $bottom   = $objStyle->getBorders()->getBottom();
                $left     = $objStyle->getBorders()->getLeft();
                $diagonal = $objStyle->getBorders()->getDiagonal();

                if (isset($top->colorIndex)) {
                    $borderTopColor = self::_readColor($top->colorIndex,$this->_palette,$this->_version);
                    $top->getColor()->setRGB($borderTopColor['rgb']);
                }

                if (isset($right->colorIndex)) {
                    $borderRightColor = self::_readColor($right->colorIndex,$this->_palette,$this->_version);
                    $right->getColor()->setRGB($borderRightColor['rgb']);
                }

                if (isset($bottom->colorIndex)) {
                    $borderBottomColor = self::_readColor($bottom->colorIndex,$this->_palette,$this->_version);
                    $bottom->getColor()->setRGB($borderBottomColor['rgb']);
                }

                if (isset($left->colorIndex)) {
                    $borderLeftColor = self::_readColor($left->colorIndex,$this->_palette,$this->_version);
                    $left->getColor()->setRGB($borderLeftColor['rgb']);
                }

                if (isset($diagonal->colorIndex)) {
                    $borderDiagonalColor = self::_readColor($diagonal->colorIndex,$this->_palette,$this->_version);
                    $diagonal->getColor()->setRGB($borderDiagonalColor['rgb']);
                }
            }
        }

        // treat MSODRAWINGGROUP records, workbook-level Escher
        if (!$this->_readDataOnly && $this->_drawingGroupData) {
            $escherWorkbook = new PHPExcel_Shared_Escher();
            $reader = new PHPExcel_Reader_Excel5_Escher($escherWorkbook);
            $escherWorkbook = $reader->load($this->_drawingGroupData);

            // debug Escher stream
            //$debug = new Debug_Escher(new PHPExcel_Shared_Escher());
            //$debug->load($this->_drawingGroupData);
        }

        // Parse the individual sheets
        foreach ($this->_sheets as $sheet) {

            if ($sheet['sheetType'] != 0x00) {
                // 0x00: Worksheet, 0x02: Chart, 0x06: Visual Basic module
                continue;
            }

            // check if sheet should be skipped
            if (isset($this->_loadSheetsOnly) && !in_array($sheet['name'], $this->_loadSheetsOnly)) {
                continue;
            }

            // add sheet to PHPExcel object
            $this->_phpSheet = $this->_phpExcel->createSheet();
            $this->_phpSheet->setTitle($sheet['name']);
            $this->_phpSheet->setSheetState($sheet['sheetState']);

            $this->_pos = $sheet['offset'];

            // Initialize isFitToPages. May change after reading SHEETPR record.
            $this->_isFitToPages = false;

            // Initialize drawingData
            $this->_drawingData = '';

            // Initialize objs
            $this->_objs = array();

            // Initialize shared formula parts
            $this->_sharedFormulaParts = array();

            // Initialize shared formulas
            $this->_sharedFormulas = array();

            // Initialize text objs
            $this->_textObjects = array();

            // Initialize cell annotations
            $this->_cellNotes = array();
            $this->textObjRef = -1;

            while ($this->_pos <= $this->_dataSize - 4) {
                $code = self::_GetInt2d($this->_data, $this->_pos);

                switch ($code) {
                    case self::XLS_Type_BOF:                    $this->_readBof();                        break;
                    case self::XLS_Type_PRINTGRIDLINES:            $this->_readPrintGridlines();            break;
                    case self::XLS_Type_DEFAULTROWHEIGHT:        $this->_readDefaultRowHeight();            break;
                    case self::XLS_Type_SHEETPR:                $this->_readSheetPr();                    break;
                    case self::XLS_Type_HORIZONTALPAGEBREAKS:    $this->_readHorizontalPageBreaks();        break;
                    case self::XLS_Type_VERTICALPAGEBREAKS:        $this->_readVerticalPageBreaks();        break;
                    case self::XLS_Type_HEADER:                    $this->_readHeader();                    break;
                    case self::XLS_Type_FOOTER:                    $this->_readFooter();                    break;
                    case self::XLS_Type_HCENTER:                $this->_readHcenter();                    break;
                    case self::XLS_Type_VCENTER:                $this->_readVcenter();                    break;
                    case self::XLS_Type_LEFTMARGIN:                $this->_readLeftMargin();                break;
                    case self::XLS_Type_RIGHTMARGIN:            $this->_readRightMargin();                break;
                    case self::XLS_Type_TOPMARGIN:                $this->_readTopMargin();                break;
                    case self::XLS_Type_BOTTOMMARGIN:            $this->_readBottomMargin();                break;
                    case self::XLS_Type_PAGESETUP:                $this->_readPageSetup();                break;
                    case self::XLS_Type_PROTECT:                $this->_readProtect();                    break;
                    case self::XLS_Type_SCENPROTECT:            $this->_readScenProtect();                break;
                    case self::XLS_Type_OBJECTPROTECT:            $this->_readObjectProtect();            break;
                    case self::XLS_Type_PASSWORD:                $this->_readPassword();                    break;
                    case self::XLS_Type_DEFCOLWIDTH:            $this->_readDefColWidth();                break;
                    case self::XLS_Type_COLINFO:                $this->_readColInfo();                    break;
                    case self::XLS_Type_DIMENSION:                $this->_readDefault();                    break;
                    case self::XLS_Type_ROW:                    $this->_readRow();                        break;
                    case self::XLS_Type_DBCELL:                    $this->_readDefault();                    break;
                    case self::XLS_Type_RK:                        $this->_readRk();                        break;
                    case self::XLS_Type_LABELSST:                $this->_readLabelSst();                    break;
                    case self::XLS_Type_MULRK:                    $this->_readMulRk();                    break;
                    case self::XLS_Type_NUMBER:                    $this->_readNumber();                    break;
                    case self::XLS_Type_FORMULA:                $this->_readFormula();                    break;
                    case self::XLS_Type_SHAREDFMLA:                $this->_readSharedFmla();                break;
                    case self::XLS_Type_BOOLERR:                $this->_readBoolErr();                    break;
                    case self::XLS_Type_MULBLANK:                $this->_readMulBlank();                    break;
                    case self::XLS_Type_LABEL:                    $this->_readLabel();                    break;
                    case self::XLS_Type_BLANK:                    $this->_readBlank();                    break;
                    case self::XLS_Type_MSODRAWING:                $this->_readMsoDrawing();                break;
                    case self::XLS_Type_OBJ:                    $this->_readObj();                        break;
                    case self::XLS_Type_WINDOW2:                $this->_readWindow2();                    break;
                    case self::XLS_Type_SCL:                    $this->_readScl();                        break;
                    case self::XLS_Type_PANE:                    $this->_readPane();                        break;
                    case self::XLS_Type_SELECTION:                $this->_readSelection();                break;
                    case self::XLS_Type_MERGEDCELLS:            $this->_readMergedCells();                break;
                    case self::XLS_Type_HYPERLINK:                $this->_readHyperLink();                break;
                    case self::XLS_Type_DATAVALIDATIONS:        $this->_readDataValidations();            break;
                    case self::XLS_Type_DATAVALIDATION:            $this->_readDataValidation();            break;
                    case self::XLS_Type_SHEETLAYOUT:            $this->_readSheetLayout();                break;
                    case self::XLS_Type_SHEETPROTECTION:        $this->_readSheetProtection();            break;
                    case self::XLS_Type_RANGEPROTECTION:        $this->_readRangeProtection();            break;
                    case self::XLS_Type_NOTE:                    $this->_readNote();                        break;
                    //case self::XLS_Type_IMDATA:                $this->_readImData();                    break;
                    case self::XLS_Type_TXO:                    $this->_readTextObject();                break;
                    case self::XLS_Type_CONTINUE:                $this->_readContinue();                    break;
                    case self::XLS_Type_EOF:                    $this->_readDefault();                    break 2;
                    default:                                    $this->_readDefault();                    break;
                }

            }

            // treat MSODRAWING records, sheet-level Escher
            if (!$this->_readDataOnly && $this->_drawingData) {
                $escherWorksheet = new PHPExcel_Shared_Escher();
                $reader = new PHPExcel_Reader_Excel5_Escher($escherWorksheet);
                $escherWorksheet = $reader->load($this->_drawingData);

                // debug Escher stream
                //$debug = new Debug_Escher(new PHPExcel_Shared_Escher());
                //$debug->load($this->_drawingData);

                // get all spContainers in one long array, so they can be mapped to OBJ records
                $allSpContainers = $escherWorksheet->getDgContainer()->getSpgrContainer()->getAllSpContainers();
            }

            // treat OBJ records
            foreach ($this->_objs as $n => $obj) {
//                echo '<hr /><b>Object</b> reference is ',$n,'<br />';
//                var_dump($obj);
//                echo '<br />';

                // the first shape container never has a corresponding OBJ record, hence $n + 1
                $spContainer = $allSpContainers[$n + 1];

                // we skip all spContainers that are a part of a group shape since we cannot yet handle those
                if ($spContainer->getNestingLevel() > 1) {
                    continue;
                }

                // calculate the width and height of the shape
                list($startColumn, $startRow) = PHPExcel_Cell::coordinateFromString($spContainer->getStartCoordinates());
                list($endColumn, $endRow) = PHPExcel_Cell::coordinateFromString($spContainer->getEndCoordinates());

                $startOffsetX = $spContainer->getStartOffsetX();
                $startOffsetY = $spContainer->getStartOffsetY();
                $endOffsetX = $spContainer->getEndOffsetX();
                $endOffsetY = $spContainer->getEndOffsetY();

                $width = PHPExcel_Shared_Excel5::getDistanceX($this->_phpSheet, $startColumn, $startOffsetX, $endColumn, $endOffsetX);
                $height = PHPExcel_Shared_Excel5::getDistanceY($this->_phpSheet, $startRow, $startOffsetY, $endRow, $endOffsetY);

                // calculate offsetX and offsetY of the shape
                $offsetX = $startOffsetX * PHPExcel_Shared_Excel5::sizeCol($this->_phpSheet, $startColumn) / 1024;
                $offsetY = $startOffsetY * PHPExcel_Shared_Excel5::sizeRow($this->_phpSheet, $startRow) / 256;

                switch ($obj['otObjType']) {

                case 0x19:
                    // Note
//                    echo 'Cell Annotation Object<br />';
//                    echo 'Object ID is ',$obj['idObjID'],'<br />';
//
                    if (isset($this->_cellNotes[$obj['idObjID']])) {
                        $cellNote = $this->_cellNotes[$obj['idObjID']];

//                        echo '_cellNotes[',$obj['idObjID'],']: ';
//                        var_dump($cellNote);
//                        echo '<br />';
//
                        if (isset($this->_textObjects[$obj['idObjID']])) {
                            $textObject = $this->_textObjects[$obj['idObjID']];
//                            echo '_textObject: ';
//                            var_dump($textObject);
//                            echo '<br />';
//
                            $this->_cellNotes[$obj['idObjID']]['objTextData'] = $textObject;
                            $text = $textObject['text'];
                        }
//                        echo $text,'<br />';
                    }
                    break;

                case 0x08:
//                    echo 'Picture Object<br />';
                    // picture

                    // get index to BSE entry (1-based)
                    $BSEindex = $spContainer->getOPT(0x0104);
                    $BSECollection = $escherWorkbook->getDggContainer()->getBstoreContainer()->getBSECollection();
                    $BSE = $BSECollection[$BSEindex - 1];
                    $blipType = $BSE->getBlipType();

                    // need check because some blip types are not supported by Escher reader such as EMF
                    if ($blip = $BSE->getBlip()) {
                        $ih = imagecreatefromstring($blip->getData());
                        $drawing = new PHPExcel_Worksheet_MemoryDrawing();
                        $drawing->setImageResource($ih);

                        // width, height, offsetX, offsetY
                        $drawing->setResizeProportional(false);
                        $drawing->setWidth($width);
                        $drawing->setHeight($height);
                        $drawing->setOffsetX($offsetX);
                        $drawing->setOffsetY($offsetY);

                        switch ($blipType) {
                            case PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_JPEG:
                                $drawing->setRenderingFunction(PHPExcel_Worksheet_MemoryDrawing::RENDERING_JPEG);
                                $drawing->setMimeType(PHPExcel_Worksheet_MemoryDrawing::MIMETYPE_JPEG);
                                break;

                            case PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_PNG:
                                $drawing->setRenderingFunction(PHPExcel_Worksheet_MemoryDrawing::RENDERING_PNG);
                                $drawing->setMimeType(PHPExcel_Worksheet_MemoryDrawing::MIMETYPE_PNG);
                                break;
                        }

                        $drawing->setWorksheet($this->_phpSheet);
                        $drawing->setCoordinates($spContainer->getStartCoordinates());
                    }

                    break;

                default:
                    // other object type
                    break;

                }
            }

            // treat SHAREDFMLA records
            if ($this->_version == self::XLS_BIFF8) {
                foreach ($this->_sharedFormulaParts as $cell => $baseCell) {
                    list($column, $row) = PHPExcel_Cell::coordinateFromString($cell);
                    if ( !is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($column, $row, $this->_phpSheet->getTitle()) ) {
                        $formula = $this->_getFormulaFromStructure($this->_sharedFormulas[$baseCell], $cell);
                        $this->_phpSheet->getCell($cell)->setValueExplicit('=' . $formula, PHPExcel_Cell_DataType::TYPE_FORMULA);
                    }
                }
            }

            if (count($this->_cellNotes) > 0) {
                foreach($this->_cellNotes as $note => $noteDetails) {
//                    echo '<b>Cell annotation ',$note,'</b><br />';
//                    var_dump($noteDetails);
//                    echo '<br />';
                    $cellAddress = str_replace('$','',$noteDetails['cellRef']);
                    $this->_phpSheet->getComment( $cellAddress )
                                                    ->setAuthor( $noteDetails['author'] )
                                                    ->setText($this->_parseRichText($noteDetails['objTextData']['text']) );
                }
            }
        }

        // add the named ranges (defined names)
        foreach ($this->_definedname as $definedName) {
            if ($definedName['isBuiltInName']) {
                switch ($definedName['name']) {

                case pack('C', 0x06):
                    // print area
                    //    in general, formula looks like this: Foo!$C$7:$J$66,Bar!$A$1:$IV$2

                    $ranges = explode(',', $definedName['formula']); // FIXME: what if sheetname contains comma?

                    $extractedRanges = array();
                    foreach ($ranges as $range) {
                        // $range should look like one of these
                        //        Foo!$C$7:$J$66
                        //        Bar!$A$1:$IV$2

                        $explodes = explode('!', $range);    // FIXME: what if sheetname contains exclamation mark?
                        $sheetName = $explodes[0];

                        if (count($explodes) == 2) {
                            $extractedRanges[] = str_replace('$', '', $explodes[1]); // C7:J66
                        }
                    }
                    if ($docSheet = $this->_phpExcel->getSheetByName($sheetName)) {
                        $docSheet->getPageSetup()->setPrintArea(implode(',', $extractedRanges)); // C7:J66,A1:IV2
                    }
                    break;

                case pack('C', 0x07):
                    // print titles (repeating rows)
                    // Assuming BIFF8, there are 3 cases
                    // 1. repeating rows
                    //        formula looks like this: Sheet!$A$1:$IV$2
                    //        rows 1-2 repeat
                    // 2. repeating columns
                    //        formula looks like this: Sheet!$A$1:$B$65536
                    //        columns A-B repeat
                    // 3. both repeating rows and repeating columns
                    //        formula looks like this: Sheet!$A$1:$B$65536,Sheet!$A$1:$IV$2

                    $ranges = explode(',', $definedName['formula']); // FIXME: what if sheetname contains comma?

                    foreach ($ranges as $range) {
                        // $range should look like this one of these
                        //        Sheet!$A$1:$B$65536
                        //        Sheet!$A$1:$IV$2

                        $explodes = explode('!', $range);

                        if (count($explodes) == 2) {
                            if ($docSheet = $this->_phpExcel->getSheetByName($explodes[0])) {

                                $extractedRange = $explodes[1];
                                $extractedRange = str_replace('$', '', $extractedRange);

                                $coordinateStrings = explode(':', $extractedRange);
                                if (count($coordinateStrings) == 2) {
                                    list($firstColumn, $firstRow) = PHPExcel_Cell::coordinateFromString($coordinateStrings[0]);
                                    list($lastColumn, $lastRow) = PHPExcel_Cell::coordinateFromString($coordinateStrings[1]);

                                    if ($firstColumn == 'A' and $lastColumn == 'IV') {
                                        // then we have repeating rows
                                        $docSheet->getPageSetup()->setRowsToRepeatAtTop(array($firstRow, $lastRow));
                                    } elseif ($firstRow == 1 and $lastRow == 65536) {
                                        // then we have repeating columns
                                        $docSheet->getPageSetup()->setColumnsToRepeatAtLeft(array($firstColumn, $lastColumn));
                                    }
                                }
                            }
                        }
                    }
                    break;

                }
            } else {
                // Extract range
                $explodes = explode('!', $definedName['formula']);

                if (count($explodes) == 2) {
                    if ($docSheet = $this->_phpExcel->getSheetByName($explodes[0])) {
                        $extractedRange = $explodes[1];
                        $extractedRange = str_replace('$', '', $extractedRange);

                        $localOnly = ($definedName['scope'] == 0) ? false : true;
                        $scope = ($definedName['scope'] == 0) ?
                            null : $this->_phpExcel->getSheetByName($this->_sheets[$definedName['scope'] - 1]['name']);

                        $this->_phpExcel->addNamedRange( new PHPExcel_NamedRange((string)$definedName['name'], $docSheet, $extractedRange, $localOnly, $scope) );
                    }
                }
            }
        }

        return $this->_phpExcel;
    }

    /**
     * Use OLE reader to extract the relevant data streams from the OLE file
     *
     * @param string $pFilename
     */
    private function _loadOLE($pFilename)
    {
        // OLE reader
        $ole = new PHPExcel_Shared_OLERead();

        // get excel data,
        $res = $ole->read($pFilename);
        // Get workbook data: workbook stream + sheet streams
        $this->_data = $ole->getStream($ole->wrkbook);

        // Get summary information data
        $this->_summaryInformation = $ole->getStream($ole->summaryInformation);

        // Get additional document summary information data
        $this->_documentSummaryInformation = $ole->getStream($ole->documentSummaryInformation);

        // Get user-defined property data
//        $this->_userDefinedProperties = $ole->getUserDefinedProperties();
    }

    /**
     * Read summary information
     */
    private function _readSummaryInformation()
    {
        if (!isset($this->_summaryInformation)) {
            return;
        }

        // offset: 0; size: 2; must be 0xFE 0xFF (UTF-16 LE byte order mark)
        // offset: 2; size: 2;
        // offset: 4; size: 2; OS version
        // offset: 6; size: 2; OS indicator
        // offset: 8; size: 16
        // offset: 24; size: 4; section count
        $secCount = self::_GetInt4d($this->_summaryInformation, 24);

        // offset: 28; size: 16; first section's class id: e0 85 9f f2 f9 4f 68 10 ab 91 08 00 2b 27 b3 d9
        // offset: 44; size: 4
        $secOffset = self::_GetInt4d($this->_summaryInformation, 44);

        // section header
        // offset: $secOffset; size: 4; section length
        $secLength = self::_GetInt4d($this->_summaryInformation, $secOffset);

        // offset: $secOffset+4; size: 4; property count
        $countProperties = self::_GetInt4d($this->_summaryInformation, $secOffset+4);

        // initialize code page (used to resolve string values)
        $codePage = 'CP1252';

        // offset: ($secOffset+8); size: var
        // loop through property decarations and properties
        for ($i = 0; $i < $countProperties; ++$i) {

            // offset: ($secOffset+8) + (8 * $i); size: 4; property ID
            $id = self::_GetInt4d($this->_summaryInformation, ($secOffset+8) + (8 * $i));

            // Use value of property id as appropriate
            // offset: ($secOffset+12) + (8 * $i); size: 4; offset from beginning of section (48)
            $offset = self::_GetInt4d($this->_summaryInformation, ($secOffset+12) + (8 * $i));

            $type = self::_GetInt4d($this->_summaryInformation, $secOffset + $offset);

            // initialize property value
            $value = null;

            // extract property value based on property type
            switch ($type) {
                case 0x02: // 2 byte signed integer
                    $value = self::_GetInt2d($this->_summaryInformation, $secOffset + 4 + $offset);
                    break;

                case 0x03: // 4 byte signed integer
                    $value = self::_GetInt4d($this->_summaryInformation, $secOffset + 4 + $offset);
                    break;

                case 0x13: // 4 byte unsigned integer
                    // not needed yet, fix later if necessary
                    break;

                case 0x1E: // null-terminated string prepended by dword string length
                    $byteLength = self::_GetInt4d($this->_summaryInformation, $secOffset + 4 + $offset);
                    $value = substr($this->_summaryInformation, $secOffset + 8 + $offset, $byteLength);
                    $value = PHPExcel_Shared_String::ConvertEncoding($value, 'UTF-8', $codePage);
                    $value = rtrim($value);
                    break;

                case 0x40: // Filetime (64-bit value representing the number of 100-nanosecond intervals since January 1, 1601)
                    // PHP-time
                    $value = PHPExcel_Shared_OLE::OLE2LocalDate(substr($this->_summaryInformation, $secOffset + 4 + $offset, 8));
                    break;

                case 0x47: // Clipboard format
                    // not needed yet, fix later if necessary
                    break;
            }

            switch ($id) {
                case 0x01:    //    Code Page
                    $codePage = PHPExcel_Shared_CodePage::NumberToName($value);
                    break;

                case 0x02:    //    Title
                    $this->_phpExcel->getProperties()->setTitle($value);
                    break;

                case 0x03:    //    Subject
                    $this->_phpExcel->getProperties()->setSubject($value);
                    break;

                case 0x04:    //    Author (Creator)
                    $this->_phpExcel->getProperties()->setCreator($value);
                    break;

                case 0x05:    //    Keywords
                    $this->_phpExcel->getProperties()->setKeywords($value);
                    break;

                case 0x06:    //    Comments (Description)
                    $this->_phpExcel->getProperties()->setDescription($value);
                    break;

                case 0x07:    //    Template
                    //    Not supported by PHPExcel
                    break;

                case 0x08:    //    Last Saved By (LastModifiedBy)
                    $this->_phpExcel->getProperties()->setLastModifiedBy($value);
                    break;

                case 0x09:    //    Revision
                    //    Not supported by PHPExcel
                    break;

                case 0x0A:    //    Total Editing Time
                    //    Not supported by PHPExcel
                    break;

                case 0x0B:    //    Last Printed
                    //    Not supported by PHPExcel
                    break;

                case 0x0C:    //    Created Date/Time
                    $this->_phpExcel->getProperties()->setCreated($value);
                    break;

                case 0x0D:    //    Modified Date/Time
                    $this->_phpExcel->getProperties()->setModified($value);
                    break;

                case 0x0E:    //    Number of Pages
                    //    Not supported by PHPExcel
                    break;

                case 0x0F:    //    Number of Words
                    //    Not supported by PHPExcel
                    break;

                case 0x10:    //    Number of Characters
                    //    Not supported by PHPExcel
                    break;

                case 0x11:    //    Thumbnail
                    //    Not supported by PHPExcel
                    break;

                case 0x12:    //    Name of creating application
                    //    Not supported by PHPExcel
                    break;

                case 0x13:    //    Security
                    //    Not supported by PHPExcel
                    break;

            }
        }
    }

    /**
     * Read additional document summary information
     */
    private function _readDocumentSummaryInformation()
    {
        if (!isset($this->_documentSummaryInformation)) {
            return;
        }

        //    offset: 0;    size: 2;    must be 0xFE 0xFF (UTF-16 LE byte order mark)
        //    offset: 2;    size: 2;
        //    offset: 4;    size: 2;    OS version
        //    offset: 6;    size: 2;    OS indicator
        //    offset: 8;    size: 16
        //    offset: 24;    size: 4;    section count
        $secCount = self::_GetInt4d($this->_documentSummaryInformation, 24);
//        echo '$secCount = ',$secCount,'<br />';

        // offset: 28;    size: 16;    first section's class id: 02 d5 cd d5 9c 2e 1b 10 93 97 08 00 2b 2c f9 ae
        // offset: 44;    size: 4;    first section offset
        $secOffset = self::_GetInt4d($this->_documentSummaryInformation, 44);
//        echo '$secOffset = ',$secOffset,'<br />';

        //    section header
        //    offset: $secOffset;    size: 4;    section length
        $secLength = self::_GetInt4d($this->_documentSummaryInformation, $secOffset);
//        echo '$secLength = ',$secLength,'<br />';

        //    offset: $secOffset+4;    size: 4;    property count
        $countProperties = self::_GetInt4d($this->_documentSummaryInformation, $secOffset+4);
//        echo '$countProperties = ',$countProperties,'<br />';

        // initialize code page (used to resolve string values)
        $codePage = 'CP1252';

        //    offset: ($secOffset+8);    size: var
        //    loop through property decarations and properties
        for ($i = 0; $i < $countProperties; ++$i) {
//            echo 'Property ',$i,'<br />';
            //    offset: ($secOffset+8) + (8 * $i);    size: 4;    property ID
            $id = self::_GetInt4d($this->_documentSummaryInformation, ($secOffset+8) + (8 * $i));
//            echo 'ID is ',$id,'<br />';

            // Use value of property id as appropriate
            // offset: 60 + 8 * $i;    size: 4;    offset from beginning of section (48)
            $offset = self::_GetInt4d($this->_documentSummaryInformation, ($secOffset+12) + (8 * $i));

            $type = self::_GetInt4d($this->_documentSummaryInformation, $secOffset + $offset);
//            echo 'Type is ',$type,', ';

            // initialize property value
            $value = null;

            // extract property value based on property type
            switch ($type) {
                case 0x02:    //    2 byte signed integer
                    $value = self::_GetInt2d($this->_documentSummaryInformation, $secOffset + 4 + $offset);
                    break;

                case 0x03:    //    4 byte signed integer
                    $value = self::_GetInt4d($this->_documentSummaryInformation, $secOffset + 4 + $offset);
                    break;

                case 0x13:    //    4 byte unsigned integer
                    // not needed yet, fix later if necessary
                    break;

                case 0x1E:    //    null-terminated string prepended by dword string length
                    $byteLength = self::_GetInt4d($this->_documentSummaryInformation, $secOffset + 4 + $offset);
                    $value = substr($this->_documentSummaryInformation, $secOffset + 8 + $offset, $byteLength);
                    $value = PHPExcel_Shared_String::ConvertEncoding($value, 'UTF-8', $codePage);
                    $value = rtrim($value);
                    break;

                case 0x40:    //    Filetime (64-bit value representing the number of 100-nanosecond intervals since January 1, 1601)
                    // PHP-Time
                    $value = PHPExcel_Shared_OLE::OLE2LocalDate(substr($this->_documentSummaryInformation, $secOffset + 4 + $offset, 8));
                    break;

                case 0x47:    //    Clipboard format
                    // not needed yet, fix later if necessary
                    break;
            }

            switch ($id) {
                case 0x01:    //    Code Page
                    $codePage = PHPExcel_Shared_CodePage::NumberToName($value);
                    break;

                case 0x02:    //    Category
                    $this->_phpExcel->getProperties()->setCategory($value);
                    break;

                case 0x03:    //    Presentation Target
                    //    Not supported by PHPExcel
                    break;

                case 0x04:    //    Bytes
                    //    Not supported by PHPExcel
                    break;

                case 0x05:    //    Lines
                    //    Not supported by PHPExcel
                    break;

                case 0x06:    //    Paragraphs
                    //    Not supported by PHPExcel
                    break;

                case 0x07:    //    Slides
                    //    Not supported by PHPExcel
                    break;

                case 0x08:    //    Notes
                    //    Not supported by PHPExcel
                    break;

                case 0x09:    //    Hidden Slides
                    //    Not supported by PHPExcel
                    break;

                case 0x0A:    //    MM Clips
                    //    Not supported by PHPExcel
                    break;

                case 0x0B:    //    Scale Crop
                    //    Not supported by PHPExcel
                    break;

                case 0x0C:    //    Heading Pairs
                    //    Not supported by PHPExcel
                    break;

                case 0x0D:    //    Titles of Parts
                    //    Not supported by PHPExcel
                    break;

                case 0x0E:    //    Manager
                    $this->_phpExcel->getProperties()->setManager($value);
                    break;

                case 0x0F:    //    Company
                    $this->_phpExcel->getProperties()->setCompany($value);
                    break;

                case 0x10:    //    Links up-to-date
                    //    Not supported by PHPExcel
                    break;

            }
        }
    }

    /**
     * Reads a general type of BIFF record. Does nothing except for moving stream pointer forward to next record.
     */
    private function _readDefault()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
//        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;
    }


    /**
     *    The NOTE record specifies a comment associated with a particular cell. In Excel 95 (BIFF7) and earlier versions,
     *        this record stores a note (cell note). This feature was significantly enhanced in Excel 97.
     */
    private function _readNote()
    {
//        echo '<b>Read Cell Annotation</b><br />';
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if ($this->_readDataOnly) {
            return;
        }

        $cellAddress = $this->_readBIFF8CellAddress(substr($recordData, 0, 4));
        if ($this->_version == self::XLS_BIFF8) {
            $noteObjID = self::_GetInt2d($recordData, 6);
            $noteAuthor = self::_readUnicodeStringLong(substr($recordData, 8));
            $noteAuthor = $noteAuthor['value'];
//            echo 'Note Address=',$cellAddress,'<br />';
//            echo 'Note Object ID=',$noteObjID,'<br />';
//            echo 'Note Author=',$noteAuthor,'<hr />';
//
            $this->_cellNotes[$noteObjID] = array('cellRef'        => $cellAddress,
                                                  'objectID'    => $noteObjID,
                                                  'author'        => $noteAuthor
                                                 );
        } else {
            $extension = false;
            if ($cellAddress == '$B$65536') {
                //    If the address row is -1 and the column is 0, (which translates as $B$65536) then this is a continuation
                //        note from the previous cell annotation. We're not yet handling this, so annotations longer than the
                //        max 2048 bytes will probably throw a wobbly.
                $row = self::_GetInt2d($recordData, 0);
                $extension = true;
                $cellAddress = array_pop(array_keys($this->_phpSheet->getComments()));
            }
//            echo 'Note Address=',$cellAddress,'<br />';

            $cellAddress = str_replace('$','',$cellAddress);
            $noteLength = self::_GetInt2d($recordData, 4);
            $noteText = trim(substr($recordData, 6));
//            echo 'Note Length=',$noteLength,'<br />';
//            echo 'Note Text=',$noteText,'<br />';

            if ($extension) {
                //    Concatenate this extension with the currently set comment for the cell
                $comment = $this->_phpSheet->getComment( $cellAddress );
                $commentText = $comment->getText()->getPlainText();
                $comment->setText($this->_parseRichText($commentText.$noteText) );
            } else {
                //    Set comment for the cell
                $this->_phpSheet->getComment( $cellAddress )
//                                                    ->setAuthor( $author )
                                                    ->setText($this->_parseRichText($noteText) );
            }
        }

    }

    /**
     *    The TEXT Object record contains the text associated with a cell annotation.
     */
    private function _readTextObject()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if ($this->_readDataOnly) {
            return;
        }

        // recordData consists of an array of subrecords looking like this:
        //    grbit: 2 bytes; Option Flags
        //    rot: 2 bytes; rotation
        //    cchText: 2 bytes; length of the text (in the first continue record)
        //    cbRuns: 2 bytes; length of the formatting (in the second continue record)
        // followed by the continuation records containing the actual text and formatting
        $grbitOpts    = self::_GetInt2d($recordData, 0);
        $rot        = self::_GetInt2d($recordData, 2);
        $cchText    = self::_GetInt2d($recordData, 10);
        $cbRuns        = self::_GetInt2d($recordData, 12);
        $text        = $this->_getSplicedRecordData();

        $this->_textObjects[$this->textObjRef] = array(
                'text'        => substr($text["recordData"],$text["spliceOffsets"][0]+1,$cchText),
                'format'    => substr($text["recordData"],$text["spliceOffsets"][1],$cbRuns),
                'alignment'    => $grbitOpts,
                'rotation'    => $rot
             );

//        echo '<b>_readTextObject()</b><br />';
//        var_dump($this->_textObjects[$this->textObjRef]);
//        echo '<br />';
    }

    /**
     * Read BOF
     */
    private function _readBof()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 2; size: 2; type of the following data
        $substreamType = self::_GetInt2d($recordData, 2);

        switch ($substreamType) {
            case self::XLS_WorkbookGlobals:
                $version = self::_GetInt2d($recordData, 0);
                if (($version != self::XLS_BIFF8) && ($version != self::XLS_BIFF7)) {
                    throw new Exception('Cannot read this Excel file. Version is too old.');
                }
                $this->_version = $version;
                break;

            case self::XLS_Worksheet:
                // do not use this version information for anything
                // it is unreliable (OpenOffice doc, 5.8), use only version information from the global stream
                break;

            default:
                // substream, e.g. chart
                // just skip the entire substream
                do {
                    $code = self::_GetInt2d($this->_data, $this->_pos);
                    $this->_readDefault();
                } while ($code != self::XLS_Type_EOF && $this->_pos < $this->_dataSize);
                break;
        }
    }

    /**
     * FILEPASS
     *
     * This record is part of the File Protection Block. It
     * contains information about the read/write password of the
     * file. All record contents following this record will be
     * encrypted.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readFilepass()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
//        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        throw new Exception('Cannot read encrypted file');
    }

    /**
     * CODEPAGE
     *
     * This record stores the text encoding used to write byte
     * strings, stored as MS Windows code page identifier.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readCodepage()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; code page identifier
        $codepage = self::_GetInt2d($recordData, 0);

        $this->_codepage = PHPExcel_Shared_CodePage::NumberToName($codepage);
    }

    /**
     * DATEMODE
     *
     * This record specifies the base date for displaying date
     * values. All dates are stored as count of days past this
     * base date. In BIFF2-BIFF4 this record is part of the
     * Calculation Settings Block. In BIFF5-BIFF8 it is
     * stored in the Workbook Globals Substream.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readDateMode()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; 0 = base 1900, 1 = base 1904
        PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900);
        if (ord($recordData{0}) == 1) {
            PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_MAC_1904);
        }
    }

    /**
     * Read a FONT record
     */
    private function _readFont()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            $objFont = new PHPExcel_Style_Font();

            // offset: 0; size: 2; height of the font (in twips = 1/20 of a point)
            $size = self::_GetInt2d($recordData, 0);
            $objFont->setSize($size / 20);

            // offset: 2; size: 2; option flags
                // bit: 0; mask 0x0001; bold (redundant in BIFF5-BIFF8)
                // bit: 1; mask 0x0002; italic
                $isItalic = (0x0002 & self::_GetInt2d($recordData, 2)) >> 1;
                if ($isItalic) $objFont->setItalic(true);

                // bit: 2; mask 0x0004; underlined (redundant in BIFF5-BIFF8)
                // bit: 3; mask 0x0008; strike
                $isStrike = (0x0008 & self::_GetInt2d($recordData, 2)) >> 3;
                if ($isStrike) $objFont->setStrikethrough(true);

            // offset: 4; size: 2; colour index
            $colorIndex = self::_GetInt2d($recordData, 4);
            $objFont->colorIndex = $colorIndex;

            // offset: 6; size: 2; font weight
            $weight = self::_GetInt2d($recordData, 6);
            switch ($weight) {
                case 0x02BC:
                    $objFont->setBold(true);
                    break;
            }

            // offset: 8; size: 2; escapement type
            $escapement = self::_GetInt2d($recordData, 8);
            switch ($escapement) {
                case 0x0001:
                    $objFont->setSuperScript(true);
                    break;
                case 0x0002:
                    $objFont->setSubScript(true);
                    break;
            }

            // offset: 10; size: 1; underline type
            $underlineType = ord($recordData{10});
            switch ($underlineType) {
                case 0x00:
                    break; // no underline
                case 0x01:
                    $objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_SINGLE);
                    break;
                case 0x02:
                    $objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_DOUBLE);
                    break;
                case 0x21:
                    $objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_SINGLEACCOUNTING);
                    break;
                case 0x22:
                    $objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_DOUBLEACCOUNTING);
                    break;
            }

            // offset: 11; size: 1; font family
            // offset: 12; size: 1; character set
            // offset: 13; size: 1; not used
            // offset: 14; size: var; font name
            if ($this->_version == self::XLS_BIFF8) {
                $string = self::_readUnicodeStringShort(substr($recordData, 14));
            } else {
                $string = $this->_readByteStringShort(substr($recordData, 14));
            }
            $objFont->setName($string['value']);

            $this->_objFonts[] = $objFont;
        }
    }

    /**
     * FORMAT
     *
     * This record contains information about a number format.
     * All FORMAT records occur together in a sequential list.
     *
     * In BIFF2-BIFF4 other records referencing a FORMAT record
     * contain a zero-based index into this list. From BIFF5 on
     * the FORMAT record contains the index itself that will be
     * used by other records.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readFormat()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            $indexCode = self::_GetInt2d($recordData, 0);

            if ($this->_version == self::XLS_BIFF8) {
                $string = self::_readUnicodeStringLong(substr($recordData, 2));
            } else {
                // BIFF7
                $string = $this->_readByteStringShort(substr($recordData, 2));
            }

            $formatString = $string['value'];
            $this->_formats[$indexCode] = $formatString;
        }
    }

    /**
     * XF - Extended Format
     *
     * This record contains formatting information for cells, rows, columns or styles.
     * According to http://support.microsoft.com/kb/147732 there are always at least 15 cell style XF
     * and 1 cell XF.
     * Inspection of Excel files generated by MS Office Excel shows that XF records 0-14 are cell style XF
     * and XF record 15 is a cell XF
     * We only read the first cell style XF and skip the remaining cell style XF records
     * We read all cell XF records.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readXf()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        $objStyle = new PHPExcel_Style();

        if (!$this->_readDataOnly) {
            // offset:  0; size: 2; Index to FONT record
            if (self::_GetInt2d($recordData, 0) < 4) {
                $fontIndex = self::_GetInt2d($recordData, 0);
            } else {
                // this has to do with that index 4 is omitted in all BIFF versions for some strange reason
                // check the OpenOffice documentation of the FONT record
                $fontIndex = self::_GetInt2d($recordData, 0) - 1;
            }
            $objStyle->setFont($this->_objFonts[$fontIndex]);

            // offset:  2; size: 2; Index to FORMAT record
            $numberFormatIndex = self::_GetInt2d($recordData, 2);
            if (isset($this->_formats[$numberFormatIndex])) {
                // then we have user-defined format code
                $numberformat = array('code' => $this->_formats[$numberFormatIndex]);
            } elseif (($code = PHPExcel_Style_NumberFormat::builtInFormatCode($numberFormatIndex)) !== '') {
                // then we have built-in format code
                $numberformat = array('code' => $code);
            } else {
                // we set the general format code
                $numberformat = array('code' => 'General');
            }
            $objStyle->getNumberFormat()->setFormatCode($numberformat['code']);

            // offset:  4; size: 2; XF type, cell protection, and parent style XF
            // bit 2-0; mask 0x0007; XF_TYPE_PROT
            $xfTypeProt = self::_GetInt2d($recordData, 4);
            // bit 0; mask 0x01; 1 = cell is locked
            $isLocked = (0x01 & $xfTypeProt) >> 0;
            $objStyle->getProtection()->setLocked($isLocked ?
                PHPExcel_Style_Protection::PROTECTION_INHERIT : PHPExcel_Style_Protection::PROTECTION_UNPROTECTED);

            // bit 1; mask 0x02; 1 = Formula is hidden
            $isHidden = (0x02 & $xfTypeProt) >> 1;
            $objStyle->getProtection()->setHidden($isHidden ?
                PHPExcel_Style_Protection::PROTECTION_PROTECTED : PHPExcel_Style_Protection::PROTECTION_UNPROTECTED);

            // bit 2; mask 0x04; 0 = Cell XF, 1 = Cell Style XF
            $isCellStyleXf = (0x04 & $xfTypeProt) >> 2;

            // offset:  6; size: 1; Alignment and text break
            // bit 2-0, mask 0x07; horizontal alignment
            $horAlign = (0x07 & ord($recordData{6})) >> 0;
            switch ($horAlign) {
                case 0:
                    $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_GENERAL);
                    break;
                case 1:
                    $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_LEFT);
                    break;
                case 2:
                    $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_CENTER);
                    break;
                case 3:
                    $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_RIGHT);
                    break;
                case 5:
                    $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_JUSTIFY);
                    break;
                case 6:
                    $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_CENTER_CONTINUOUS);
                    break;
            }
            // bit 3, mask 0x08; wrap text
            $wrapText = (0x08 & ord($recordData{6})) >> 3;
            switch ($wrapText) {
                case 0:
                    $objStyle->getAlignment()->setWrapText(false);
                    break;
                case 1:
                    $objStyle->getAlignment()->setWrapText(true);
                    break;
            }
            // bit 6-4, mask 0x70; vertical alignment
            $vertAlign = (0x70 & ord($recordData{6})) >> 4;
            switch ($vertAlign) {
                case 0:
                    $objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_TOP);
                    break;
                case 1:
                    $objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_CENTER);
                    break;
                case 2:
                    $objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_BOTTOM);
                    break;
                case 3:
                    $objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_JUSTIFY);
                    break;
            }

            if ($this->_version == self::XLS_BIFF8) {
                // offset:  7; size: 1; XF_ROTATION: Text rotation angle
                    $angle = ord($recordData{7});
                    $rotation = 0;
                    if ($angle <= 90) {
                        $rotation = $angle;
                    } else if ($angle <= 180) {
                        $rotation = 90 - $angle;
                    } else if ($angle == 255) {
                        $rotation = -165;
                    }
                    $objStyle->getAlignment()->setTextRotation($rotation);

                // offset:  8; size: 1; Indentation, shrink to cell size, and text direction
                    // bit: 3-0; mask: 0x0F; indent level
                    $indent = (0x0F & ord($recordData{8})) >> 0;
                    $objStyle->getAlignment()->setIndent($indent);

                    // bit: 4; mask: 0x10; 1 = shrink content to fit into cell
                    $shrinkToFit = (0x10 & ord($recordData{8})) >> 4;
                    switch ($shrinkToFit) {
                        case 0:
                            $objStyle->getAlignment()->setShrinkToFit(false);
                            break;
                        case 1:
                            $objStyle->getAlignment()->setShrinkToFit(true);
                            break;
                    }

                // offset:  9; size: 1; Flags used for attribute groups

                // offset: 10; size: 4; Cell border lines and background area
                    // bit: 3-0; mask: 0x0000000F; left style
                    if ($bordersLeftStyle = self::_mapBorderStyle((0x0000000F & self::_GetInt4d($recordData, 10)) >> 0)) {
                        $objStyle->getBorders()->getLeft()->setBorderStyle($bordersLeftStyle);
                    }
                    // bit: 7-4; mask: 0x000000F0; right style
                    if ($bordersRightStyle = self::_mapBorderStyle((0x000000F0 & self::_GetInt4d($recordData, 10)) >> 4)) {
                        $objStyle->getBorders()->getRight()->setBorderStyle($bordersRightStyle);
                    }
                    // bit: 11-8; mask: 0x00000F00; top style
                    if ($bordersTopStyle = self::_mapBorderStyle((0x00000F00 & self::_GetInt4d($recordData, 10)) >> 8)) {
                        $objStyle->getBorders()->getTop()->setBorderStyle($bordersTopStyle);
                    }
                    // bit: 15-12; mask: 0x0000F000; bottom style
                    if ($bordersBottomStyle = self::_mapBorderStyle((0x0000F000 & self::_GetInt4d($recordData, 10)) >> 12)) {
                        $objStyle->getBorders()->getBottom()->setBorderStyle($bordersBottomStyle);
                    }
                    // bit: 22-16; mask: 0x007F0000; left color
                    $objStyle->getBorders()->getLeft()->colorIndex = (0x007F0000 & self::_GetInt4d($recordData, 10)) >> 16;

                    // bit: 29-23; mask: 0x3F800000; right color
                    $objStyle->getBorders()->getRight()->colorIndex = (0x3F800000 & self::_GetInt4d($recordData, 10)) >> 23;

                    // bit: 30; mask: 0x40000000; 1 = diagonal line from top left to right bottom
                    $diagonalDown = (0x40000000 & self::_GetInt4d($recordData, 10)) >> 30 ?
                        true : false;

                    // bit: 31; mask: 0x80000000; 1 = diagonal line from bottom left to top right
                    $diagonalUp = (0x80000000 & self::_GetInt4d($recordData, 10)) >> 31 ?
                        true : false;

                    if ($diagonalUp == false && $diagonalDown == false) {
                        $objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_NONE);
                    } elseif ($diagonalUp == true && $diagonalDown == false) {
                        $objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_UP);
                    } elseif ($diagonalUp == false && $diagonalDown == true) {
                        $objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_DOWN);
                    } elseif ($diagonalUp == true && $diagonalDown == true) {
                        $objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_BOTH);
                    }

                // offset: 14; size: 4;
                    // bit: 6-0; mask: 0x0000007F; top color
                    $objStyle->getBorders()->getTop()->colorIndex = (0x0000007F & self::_GetInt4d($recordData, 14)) >> 0;

                    // bit: 13-7; mask: 0x00003F80; bottom color
                    $objStyle->getBorders()->getBottom()->colorIndex = (0x00003F80 & self::_GetInt4d($recordData, 14)) >> 7;

                    // bit: 20-14; mask: 0x001FC000; diagonal color
                    $objStyle->getBorders()->getDiagonal()->colorIndex = (0x001FC000 & self::_GetInt4d($recordData, 14)) >> 14;

                    // bit: 24-21; mask: 0x01E00000; diagonal style
                    if ($bordersDiagonalStyle = self::_mapBorderStyle((0x01E00000 & self::_GetInt4d($recordData, 14)) >> 21)) {
                        $objStyle->getBorders()->getDiagonal()->setBorderStyle($bordersDiagonalStyle);
                    }

                    // bit: 31-26; mask: 0xFC000000 fill pattern
                    if ($fillType = self::_mapFillPattern((0xFC000000 & self::_GetInt4d($recordData, 14)) >> 26)) {
                        $objStyle->getFill()->setFillType($fillType);
                    }
                // offset: 18; size: 2; pattern and background colour
                    // bit: 6-0; mask: 0x007F; color index for pattern color
                    $objStyle->getFill()->startcolorIndex = (0x007F & self::_GetInt2d($recordData, 18)) >> 0;

                    // bit: 13-7; mask: 0x3F80; color index for pattern background
                    $objStyle->getFill()->endcolorIndex = (0x3F80 & self::_GetInt2d($recordData, 18)) >> 7;
            } else {
                // BIFF5

                // offset: 7; size: 1; Text orientation and flags
                $orientationAndFlags = ord($recordData{7});

                // bit: 1-0; mask: 0x03; XF_ORIENTATION: Text orientation
                $xfOrientation = (0x03 & $orientationAndFlags) >> 0;
                switch ($xfOrientation) {
                    case 0:
                        $objStyle->getAlignment()->setTextRotation(0);
                        break;
                    case 1:
                        $objStyle->getAlignment()->setTextRotation(-165);
                        break;
                    case 2:
                        $objStyle->getAlignment()->setTextRotation(90);
                        break;
                    case 3:
                        $objStyle->getAlignment()->setTextRotation(-90);
                        break;
                }

                // offset: 8; size: 4; cell border lines and background area
                $borderAndBackground = self::_GetInt4d($recordData, 8);

                // bit: 6-0; mask: 0x0000007F; color index for pattern color
                $objStyle->getFill()->startcolorIndex = (0x0000007F & $borderAndBackground) >> 0;

                // bit: 13-7; mask: 0x00003F80; color index for pattern background
                $objStyle->getFill()->endcolorIndex = (0x00003F80 & $borderAndBackground) >> 7;

                // bit: 21-16; mask: 0x003F0000; fill pattern
                $objStyle->getFill()->setFillType(self::_mapFillPattern((0x003F0000 & $borderAndBackground) >> 16));

                // bit: 24-22; mask: 0x01C00000; bottom line style
                $objStyle->getBorders()->getBottom()->setBorderStyle(self::_mapBorderStyle((0x01C00000 & $borderAndBackground) >> 22));

                // bit: 31-25; mask: 0xFE000000; bottom line color
                $objStyle->getBorders()->getBottom()->colorIndex = (0xFE000000 & $borderAndBackground) >> 25;

                // offset: 12; size: 4; cell border lines
                $borderLines = self::_GetInt4d($recordData, 12);

                // bit: 2-0; mask: 0x00000007; top line style
                $objStyle->getBorders()->getTop()->setBorderStyle(self::_mapBorderStyle((0x00000007 & $borderLines) >> 0));

                // bit: 5-3; mask: 0x00000038; left line style
                $objStyle->getBorders()->getLeft()->setBorderStyle(self::_mapBorderStyle((0x00000038 & $borderLines) >> 3));

                // bit: 8-6; mask: 0x000001C0; right line style
                $objStyle->getBorders()->getRight()->setBorderStyle(self::_mapBorderStyle((0x000001C0 & $borderLines) >> 6));

                // bit: 15-9; mask: 0x0000FE00; top line color index
                $objStyle->getBorders()->getTop()->colorIndex = (0x0000FE00 & $borderLines) >> 9;

                // bit: 22-16; mask: 0x007F0000; left line color index
                $objStyle->getBorders()->getLeft()->colorIndex = (0x007F0000 & $borderLines) >> 16;

                // bit: 29-23; mask: 0x3F800000; right line color index
                $objStyle->getBorders()->getRight()->colorIndex = (0x3F800000 & $borderLines) >> 23;
            }

            // add cellStyleXf or cellXf and update mapping
            if ($isCellStyleXf) {
                // we only read one style XF record which is always the first
                if ($this->_xfIndex == 0) {
                    $this->_phpExcel->addCellStyleXf($objStyle);
                    $this->_mapCellStyleXfIndex[$this->_xfIndex] = 0;
                }
            } else {
                // we read all cell XF records
                $this->_phpExcel->addCellXf($objStyle);
                $this->_mapCellXfIndex[$this->_xfIndex] = count($this->_phpExcel->getCellXfCollection()) - 1;
            }

            // update XF index for when we read next record
            ++$this->_xfIndex;
        }
    }

    /**
     *
     */
    private function _readXfExt()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 2; 0x087D = repeated header

            // offset: 2; size: 2

            // offset: 4; size: 8; not used

            // offset: 12; size: 2; record version

            // offset: 14; size: 2; index to XF record which this record modifies
            $ixfe = self::_GetInt2d($recordData, 14);

            // offset: 16; size: 2; not used

            // offset: 18; size: 2; number of extension properties that follow
            $cexts = self::_GetInt2d($recordData, 18);

            // start reading the actual extension data
            $offset = 20;
            while ($offset < $length) {
                // extension type
                $extType = self::_GetInt2d($recordData, $offset);

                // extension length
                $cb = self::_GetInt2d($recordData, $offset + 2);

                // extension data
                $extData = substr($recordData, $offset + 4, $cb);

                switch ($extType) {
                    case 4:        // fill start color
                        $xclfType  = self::_GetInt2d($extData, 0); // color type
                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        if ($xclfType == 2) {
                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            // modify the relevant style property
                            if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
                                $fill = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFill();
                                $fill->getStartColor()->setRGB($rgb);
                                unset($fill->startcolorIndex); // normal color index does not apply, discard
                            }
                        }
                        break;

                    case 5:        // fill end color
                        $xclfType  = self::_GetInt2d($extData, 0); // color type
                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        if ($xclfType == 2) {
                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            // modify the relevant style property
                            if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
                                $fill = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFill();
                                $fill->getEndColor()->setRGB($rgb);
                                unset($fill->endcolorIndex); // normal color index does not apply, discard
                            }
                        }
                        break;

                    case 7:        // border color top
                        $xclfType  = self::_GetInt2d($extData, 0); // color type
                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        if ($xclfType == 2) {
                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            // modify the relevant style property
                            if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
                                $top = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getTop();
                                $top->getColor()->setRGB($rgb);
                                unset($top->colorIndex); // normal color index does not apply, discard
                            }
                        }
                        break;

                    case 8:        // border color bottom
                        $xclfType  = self::_GetInt2d($extData, 0); // color type
                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        if ($xclfType == 2) {
                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            // modify the relevant style property
                            if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
                                $bottom = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getBottom();
                                $bottom->getColor()->setRGB($rgb);
                                unset($bottom->colorIndex); // normal color index does not apply, discard
                            }
                        }
                        break;

                    case 9:        // border color left
                        $xclfType  = self::_GetInt2d($extData, 0); // color type
                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        if ($xclfType == 2) {
                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            // modify the relevant style property
                            if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
                                $left = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getLeft();
                                $left->getColor()->setRGB($rgb);
                                unset($left->colorIndex); // normal color index does not apply, discard
                            }
                        }
                        break;

                    case 10:        // border color right
                        $xclfType  = self::_GetInt2d($extData, 0); // color type
                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        if ($xclfType == 2) {
                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            // modify the relevant style property
                            if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
                                $right = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getRight();
                                $right->getColor()->setRGB($rgb);
                                unset($right->colorIndex); // normal color index does not apply, discard
                            }
                        }
                        break;

                    case 11:        // border color diagonal
                        $xclfType  = self::_GetInt2d($extData, 0); // color type
                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        if ($xclfType == 2) {
                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            // modify the relevant style property
                            if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
                                $diagonal = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getDiagonal();
                                $diagonal->getColor()->setRGB($rgb);
                                unset($diagonal->colorIndex); // normal color index does not apply, discard
                            }
                        }
                        break;

                    case 13:    // font color
                        $xclfType  = self::_GetInt2d($extData, 0); // color type
                        $xclrValue = substr($extData, 4, 4); // color value (value based on color type)

                        if ($xclfType == 2) {
                            $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));

                            // modify the relevant style property
                            if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
                                $font = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFont();
                                $font->getColor()->setRGB($rgb);
                                unset($font->colorIndex); // normal color index does not apply, discard
                            }
                        }
                        break;
                }

                $offset += $cb;
            }
        }

    }

    /**
     * Read STYLE record
     */
    private function _readStyle()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 2; index to XF record and flag for built-in style
            $ixfe = self::_GetInt2d($recordData, 0);

            // bit: 11-0; mask 0x0FFF; index to XF record
            $xfIndex = (0x0FFF & $ixfe) >> 0;

            // bit: 15; mask 0x8000; 0 = user-defined style, 1 = built-in style
            $isBuiltIn = (bool) ((0x8000 & $ixfe) >> 15);

            if ($isBuiltIn) {
                // offset: 2; size: 1; identifier for built-in style
                $builtInId = ord($recordData{2});

                switch ($builtInId) {
                case 0x00:
                    // currently, we are not using this for anything
                    break;

                default:
                    break;
                }

            } else {
                // user-defined; not supported by PHPExcel
            }
        }
    }

    /**
     * Read PALETTE record
     */
    private function _readPalette()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 2; number of following colors
            $nm = self::_GetInt2d($recordData, 0);

            // list of RGB colors
            for ($i = 0; $i < $nm; ++$i) {
                $rgb = substr($recordData, 2 + 4 * $i, 4);
                $this->_palette[] = self::_readRGB($rgb);
            }
        }
    }

    /**
     * SHEET
     *
     * This record is  located in the  Workbook Globals
     * Substream  and represents a sheet inside the workbook.
     * One SHEET record is written for each sheet. It stores the
     * sheet name and a stream offset to the BOF record of the
     * respective Sheet Substream within the Workbook Stream.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readSheet()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 4; absolute stream position of the BOF record of the sheet
        $rec_offset = self::_GetInt4d($recordData, 0);

        // offset: 4; size: 1; sheet state
        switch (ord($recordData{4})) {
            case 0x00: $sheetState = PHPExcel_Worksheet::SHEETSTATE_VISIBLE;    break;
            case 0x01: $sheetState = PHPExcel_Worksheet::SHEETSTATE_HIDDEN;     break;
            case 0x02: $sheetState = PHPExcel_Worksheet::SHEETSTATE_VERYHIDDEN; break;
            default: $sheetState = PHPExcel_Worksheet::SHEETSTATE_VISIBLE;      break;
        }

        // offset: 5; size: 1; sheet type
        $sheetType = ord($recordData{5});

        // offset: 6; size: var; sheet name
        if ($this->_version == self::XLS_BIFF8) {
            $string = self::_readUnicodeStringShort(substr($recordData, 6));
            $rec_name = $string['value'];
        } elseif ($this->_version == self::XLS_BIFF7) {
            $string = $this->_readByteStringShort(substr($recordData, 6));
            $rec_name = $string['value'];
        }

        $this->_sheets[] = array(
            'name' => $rec_name,
            'offset' => $rec_offset,
            'sheetState' => $sheetState,
            'sheetType' => $sheetType,
        );
    }

    /**
     * Read EXTERNALBOOK record
     */
    private function _readExternalBook()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset within record data
        $offset = 0;

        // there are 4 types of records
        if (strlen($recordData) > 4) {
            // external reference
            // offset: 0; size: 2; number of sheet names ($nm)
            $nm = self::_GetInt2d($recordData, 0);
            $offset += 2;

            // offset: 2; size: var; encoded URL without sheet name (Unicode string, 16-bit length)
            $encodedUrlString = self::_readUnicodeStringLong(substr($recordData, 2));
            $offset += $encodedUrlString['size'];

            // offset: var; size: var; list of $nm sheet names (Unicode strings, 16-bit length)
            $externalSheetNames = array();
            for ($i = 0; $i < $nm; ++$i) {
                $externalSheetNameString = self::_readUnicodeStringLong(substr($recordData, $offset));
                $externalSheetNames[] = $externalSheetNameString['value'];
                $offset += $externalSheetNameString['size'];
            }

            // store the record data
            $this->_externalBooks[] = array(
                'type' => 'external',
                'encodedUrl' => $encodedUrlString['value'],
                'externalSheetNames' => $externalSheetNames,
            );

        } elseif (substr($recordData, 2, 2) == pack('CC', 0x01, 0x04)) {
            // internal reference
            // offset: 0; size: 2; number of sheet in this document
            // offset: 2; size: 2; 0x01 0x04
            $this->_externalBooks[] = array(
                'type' => 'internal',
            );
        } elseif (substr($recordData, 0, 4) == pack('vCC', 0x0001, 0x01, 0x3A)) {
            // add-in function
            // offset: 0; size: 2; 0x0001
            $this->_externalBooks[] = array(
                'type' => 'addInFunction',
            );
        } elseif (substr($recordData, 0, 2) == pack('v', 0x0000)) {
            // DDE links, OLE links
            // offset: 0; size: 2; 0x0000
            // offset: 2; size: var; encoded source document name
            $this->_externalBooks[] = array(
                'type' => 'DDEorOLE',
            );
        }
    }

    /**
     * Read EXTERNNAME record.
     */
    private function _readExternName()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // external sheet references provided for named cells
        if ($this->_version == self::XLS_BIFF8) {
            // offset: 0; size: 2; options
            $options = self::_GetInt2d($recordData, 0);

            // offset: 2; size: 2;

            // offset: 4; size: 2; not used

            // offset: 6; size: var
            $nameString = self::_readUnicodeStringShort(substr($recordData, 6));

            // offset: var; size: var; formula data
            $offset = 6 + $nameString['size'];
            $formula = $this->_getFormulaFromStructure(substr($recordData, $offset));

            $this->_externalNames[] = array(
                'name' => $nameString['value'],
                'formula' => $formula,
            );
        }
    }

    /**
     * Read EXTERNSHEET record
     */
    private function _readExternSheet()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // external sheet references provided for named cells
        if ($this->_version == self::XLS_BIFF8) {
            // offset: 0; size: 2; number of following ref structures
            $nm = self::_GetInt2d($recordData, 0);
            for ($i = 0; $i < $nm; ++$i) {
                $this->_ref[] = array(
                    // offset: 2 + 6 * $i; index to EXTERNALBOOK record
                    'externalBookIndex' => self::_GetInt2d($recordData, 2 + 6 * $i),
                    // offset: 4 + 6 * $i; index to first sheet in EXTERNALBOOK record
                    'firstSheetIndex' => self::_GetInt2d($recordData, 4 + 6 * $i),
                    // offset: 6 + 6 * $i; index to last sheet in EXTERNALBOOK record
                    'lastSheetIndex' => self::_GetInt2d($recordData, 6 + 6 * $i),
                );
            }
        }
    }

    /**
     * DEFINEDNAME
     *
     * This record is part of a Link Table. It contains the name
     * and the token array of an internal defined name. Token
     * arrays of defined names contain tokens with aberrant
     * token classes.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readDefinedName()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if ($this->_version == self::XLS_BIFF8) {
            // retrieves named cells

            // offset: 0; size: 2; option flags
            $opts = self::_GetInt2d($recordData, 0);

                // bit: 5; mask: 0x0020; 0 = user-defined name, 1 = built-in-name
                $isBuiltInName = (0x0020 & $opts) >> 5;

            // offset: 2; size: 1; keyboard shortcut

            // offset: 3; size: 1; length of the name (character count)
            $nlen = ord($recordData{3});

            // offset: 4; size: 2; size of the formula data (it can happen that this is zero)
            // note: there can also be additional data, this is not included in $flen
            $flen = self::_GetInt2d($recordData, 4);

            // offset: 8; size: 2; 0=Global name, otherwise index to sheet (1-based)
            $scope = self::_GetInt2d($recordData, 8);

            // offset: 14; size: var; Name (Unicode string without length field)
            $string = self::_readUnicodeString(substr($recordData, 14), $nlen);

            // offset: var; size: $flen; formula data
            $offset = 14 + $string['size'];
            $formulaStructure = pack('v', $flen) . substr($recordData, $offset);

            try {
                $formula = $this->_getFormulaFromStructure($formulaStructure);
            } catch (Exception $e) {
                $formula = '';
            }

            $this->_definedname[] = array(
                'isBuiltInName' => $isBuiltInName,
                'name' => $string['value'],
                'formula' => $formula,
                'scope' => $scope,
            );
        }
    }

    /**
     * Read MSODRAWINGGROUP record
     */
    private function _readMsoDrawingGroup()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);

        // get spliced record data
        $splicedRecordData = $this->_getSplicedRecordData();
        $recordData = $splicedRecordData['recordData'];

        $this->_drawingGroupData .= $recordData;
    }

    /**
     * SST - Shared String Table
     *
     * This record contains a list of all strings used anywhere
     * in the workbook. Each string occurs only once. The
     * workbook uses indexes into the list to reference the
     * strings.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     **/
    private function _readSst()
    {
        // offset within (spliced) record data
        $pos = 0;

        // get spliced record data
        $splicedRecordData = $this->_getSplicedRecordData();

        $recordData = $splicedRecordData['recordData'];
        $spliceOffsets = $splicedRecordData['spliceOffsets'];

        // offset: 0; size: 4; total number of strings in the workbook
        $pos += 4;

        // offset: 4; size: 4; number of following strings ($nm)
        $nm = self::_GetInt4d($recordData, 4);
        $pos += 4;

        // loop through the Unicode strings (16-bit length)
        for ($i = 0; $i < $nm; ++$i) {

            // number of characters in the Unicode string
            $numChars = self::_GetInt2d($recordData, $pos);
            $pos += 2;

            // option flags
            $optionFlags = ord($recordData{$pos});
            ++$pos;

            // bit: 0; mask: 0x01; 0 = compressed; 1 = uncompressed
            $isCompressed = (($optionFlags & 0x01) == 0) ;

            // bit: 2; mask: 0x02; 0 = ordinary; 1 = Asian phonetic
            $hasAsian = (($optionFlags & 0x04) != 0);

            // bit: 3; mask: 0x03; 0 = ordinary; 1 = Rich-Text
            $hasRichText = (($optionFlags & 0x08) != 0);

            if ($hasRichText) {
                // number of Rich-Text formatting runs
                $formattingRuns = self::_GetInt2d($recordData, $pos);
                $pos += 2;
            }

            if ($hasAsian) {
                // size of Asian phonetic setting
                $extendedRunLength = self::_GetInt4d($recordData, $pos);
                $pos += 4;
            }

            // expected byte length of character array if not split
            $len = ($isCompressed) ? $numChars : $numChars * 2;

            // look up limit position
            foreach ($spliceOffsets as $spliceOffset) {
                // it can happen that the string is empty, therefore we need
                // <= and not just <
                if ($pos <= $spliceOffset) {
                    $limitpos = $spliceOffset;
                    break;
                }
            }

            if ($pos + $len <= $limitpos) {
                // character array is not split between records

                $retstr = substr($recordData, $pos, $len);
                $pos += $len;

            } else {
                // character array is split between records

                // first part of character array
                $retstr = substr($recordData, $pos, $limitpos - $pos);

                $bytesRead = $limitpos - $pos;

                // remaining characters in Unicode string
                $charsLeft = $numChars - (($isCompressed) ? $bytesRead : ($bytesRead / 2));

                $pos = $limitpos;

                // keep reading the characters
                while ($charsLeft > 0) {

                    // look up next limit position, in case the string span more than one continue record
                    foreach ($spliceOffsets as $spliceOffset) {
                        if ($pos < $spliceOffset) {
                            $limitpos = $spliceOffset;
                            break;
                        }
                    }

                    // repeated option flags
                    // OpenOffice.org documentation 5.21
                    $option = ord($recordData{$pos});
                    ++$pos;

                    if ($isCompressed && ($option == 0)) {
                        // 1st fragment compressed
                        // this fragment compressed
                        $len = min($charsLeft, $limitpos - $pos);
                        $retstr .= substr($recordData, $pos, $len);
                        $charsLeft -= $len;
                        $isCompressed = true;

                    } elseif (!$isCompressed && ($option != 0)) {
                        // 1st fragment uncompressed
                        // this fragment uncompressed
                        $len = min($charsLeft * 2, $limitpos - $pos);
                        $retstr .= substr($recordData, $pos, $len);
                        $charsLeft -= $len / 2;
                        $isCompressed = false;

                    } elseif (!$isCompressed && ($option == 0)) {
                        // 1st fragment uncompressed
                        // this fragment compressed
                        $len = min($charsLeft, $limitpos - $pos);
                        for ($j = 0; $j < $len; ++$j) {
                            $retstr .= $recordData{$pos + $j} . chr(0);
                        }
                        $charsLeft -= $len;
                        $isCompressed = false;

                    } else {
                        // 1st fragment compressed
                        // this fragment uncompressed
                        $newstr = '';
                        for ($j = 0; $j < strlen($retstr); ++$j) {
                            $newstr .= $retstr[$j] . chr(0);
                        }
                        $retstr = $newstr;
                        $len = min($charsLeft * 2, $limitpos - $pos);
                        $retstr .= substr($recordData, $pos, $len);
                        $charsLeft -= $len / 2;
                        $isCompressed = false;
                    }

                    $pos += $len;
                }
            }

            // convert to UTF-8
            $retstr = self::_encodeUTF16($retstr, $isCompressed);

            // read additional Rich-Text information, if any
            $fmtRuns = array();
            if ($hasRichText) {
                // list of formatting runs
                for ($j = 0; $j < $formattingRuns; ++$j) {
                    // first formatted character; zero-based
                    $charPos = self::_GetInt2d($recordData, $pos + $j * 4);

                    // index to font record
                    $fontIndex = self::_GetInt2d($recordData, $pos + 2 + $j * 4);

                    $fmtRuns[] = array(
                        'charPos' => $charPos,
                        'fontIndex' => $fontIndex,
                    );
                }
                $pos += 4 * $formattingRuns;
            }

            // read additional Asian phonetics information, if any
            if ($hasAsian) {
                // For Asian phonetic settings, we skip the extended string data
                $pos += $extendedRunLength;
            }

            // store the shared sting
            $this->_sst[] = array(
                'value' => $retstr,
                'fmtRuns' => $fmtRuns,
            );
        }

        // _getSplicedRecordData() takes care of moving current position in data stream
    }

    /**
     * Read PRINTGRIDLINES record
     */
    private function _readPrintGridlines()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) {
            // offset: 0; size: 2; 0 = do not print sheet grid lines; 1 = print sheet gridlines
            $printGridlines = (bool) self::_GetInt2d($recordData, 0);
            $this->_phpSheet->setPrintGridlines($printGridlines);
        }
    }

    /**
     * Read DEFAULTROWHEIGHT record
     */
    private function _readDefaultRowHeight()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; option flags
        // offset: 2; size: 2; default height for unused rows, (twips 1/20 point)
        $height = self::_GetInt2d($recordData, 2);
        $this->_phpSheet->getDefaultRowDimension()->setRowHeight($height / 20);
    }

    /**
     * Read SHEETPR record
     */
    private function _readSheetPr()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2

        // bit: 6; mask: 0x0040; 0 = outline buttons above outline group
        $isSummaryBelow = (0x0040 & self::_GetInt2d($recordData, 0)) >> 6;
        $this->_phpSheet->setShowSummaryBelow($isSummaryBelow);

        // bit: 7; mask: 0x0080; 0 = outline buttons left of outline group
        $isSummaryRight = (0x0080 & self::_GetInt2d($recordData, 0)) >> 7;
        $this->_phpSheet->setShowSummaryRight($isSummaryRight);

        // bit: 8; mask: 0x100; 0 = scale printout in percent, 1 = fit printout to number of pages
        // this corresponds to radio button setting in page setup dialog in Excel
        $this->_isFitToPages = (bool) ((0x0100 & self::_GetInt2d($recordData, 0)) >> 8);
    }

    /**
     * Read HORIZONTALPAGEBREAKS record
     */
    private function _readHorizontalPageBreaks()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) {

            // offset: 0; size: 2; number of the following row index structures
            $nm = self::_GetInt2d($recordData, 0);

            // offset: 2; size: 6 * $nm; list of $nm row index structures
            for ($i = 0; $i < $nm; ++$i) {
                $r = self::_GetInt2d($recordData, 2 + 6 * $i);
                $cf = self::_GetInt2d($recordData, 2 + 6 * $i + 2);
                $cl = self::_GetInt2d($recordData, 2 + 6 * $i + 4);

                // not sure why two column indexes are necessary?
                $this->_phpSheet->setBreakByColumnAndRow($cf, $r, PHPExcel_Worksheet::BREAK_ROW);
            }
        }
    }

    /**
     * Read VERTICALPAGEBREAKS record
     */
    private function _readVerticalPageBreaks()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) {
            // offset: 0; size: 2; number of the following column index structures
            $nm = self::_GetInt2d($recordData, 0);

            // offset: 2; size: 6 * $nm; list of $nm row index structures
            for ($i = 0; $i < $nm; ++$i) {
                $c = self::_GetInt2d($recordData, 2 + 6 * $i);
                $rf = self::_GetInt2d($recordData, 2 + 6 * $i + 2);
                $rl = self::_GetInt2d($recordData, 2 + 6 * $i + 4);

                // not sure why two row indexes are necessary?
                $this->_phpSheet->setBreakByColumnAndRow($c, $rf, PHPExcel_Worksheet::BREAK_COLUMN);
            }
        }
    }

    /**
     * Read HEADER record
     */
    private function _readHeader()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: var
            // realized that $recordData can be empty even when record exists
            if ($recordData) {
                if ($this->_version == self::XLS_BIFF8) {
                    $string = self::_readUnicodeStringLong($recordData);
                } else {
                    $string = $this->_readByteStringShort($recordData);
                }

                $this->_phpSheet->getHeaderFooter()->setOddHeader($string['value']);
                $this->_phpSheet->getHeaderFooter()->setEvenHeader($string['value']);
            }
        }
    }

    /**
     * Read FOOTER record
     */
    private function _readFooter()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: var
            // realized that $recordData can be empty even when record exists
            if ($recordData) {
                if ($this->_version == self::XLS_BIFF8) {
                    $string = self::_readUnicodeStringLong($recordData);
                } else {
                    $string = $this->_readByteStringShort($recordData);
                }
                $this->_phpSheet->getHeaderFooter()->setOddFooter($string['value']);
                $this->_phpSheet->getHeaderFooter()->setEvenFooter($string['value']);
            }
        }
    }

    /**
     * Read HCENTER record
     */
    private function _readHcenter()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 2; 0 = print sheet left aligned, 1 = print sheet centered horizontally
            $isHorizontalCentered = (bool) self::_GetInt2d($recordData, 0);

            $this->_phpSheet->getPageSetup()->setHorizontalCentered($isHorizontalCentered);
        }
    }

    /**
     * Read VCENTER record
     */
    private function _readVcenter()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 2; 0 = print sheet aligned at top page border, 1 = print sheet vertically centered
            $isVerticalCentered = (bool) self::_GetInt2d($recordData, 0);

            $this->_phpSheet->getPageSetup()->setVerticalCentered($isVerticalCentered);
        }
    }

    /**
     * Read LEFTMARGIN record
     */
    private function _readLeftMargin()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 8
            $this->_phpSheet->getPageMargins()->setLeft(self::_extractNumber($recordData));
        }
    }

    /**
     * Read RIGHTMARGIN record
     */
    private function _readRightMargin()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 8
            $this->_phpSheet->getPageMargins()->setRight(self::_extractNumber($recordData));
        }
    }

    /**
     * Read TOPMARGIN record
     */
    private function _readTopMargin()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 8
            $this->_phpSheet->getPageMargins()->setTop(self::_extractNumber($recordData));
        }
    }

    /**
     * Read BOTTOMMARGIN record
     */
    private function _readBottomMargin()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 8
            $this->_phpSheet->getPageMargins()->setBottom(self::_extractNumber($recordData));
        }
    }

    /**
     * Read PAGESETUP record
     */
    private function _readPageSetup()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 2; paper size
            $paperSize = self::_GetInt2d($recordData, 0);

            // offset: 2; size: 2; scaling factor
            $scale = self::_GetInt2d($recordData, 2);

            // offset: 6; size: 2; fit worksheet width to this number of pages, 0 = use as many as needed
            $fitToWidth = self::_GetInt2d($recordData, 6);

            // offset: 8; size: 2; fit worksheet height to this number of pages, 0 = use as many as needed
            $fitToHeight = self::_GetInt2d($recordData, 8);

            // offset: 10; size: 2; option flags

                // bit: 1; mask: 0x0002; 0=landscape, 1=portrait
                $isPortrait = (0x0002 & self::_GetInt2d($recordData, 10)) >> 1;

                // bit: 2; mask: 0x0004; 1= paper size, scaling factor, paper orient. not init
                // when this bit is set, do not use flags for those properties
                $isNotInit = (0x0004 & self::_GetInt2d($recordData, 10)) >> 2;

            if (!$isNotInit) {
                $this->_phpSheet->getPageSetup()->setPaperSize($paperSize);
                switch ($isPortrait) {
                case 0: $this->_phpSheet->getPageSetup()->setOrientation(PHPExcel_Worksheet_PageSetup::ORIENTATION_LANDSCAPE); break;
                case 1: $this->_phpSheet->getPageSetup()->setOrientation(PHPExcel_Worksheet_PageSetup::ORIENTATION_PORTRAIT); break;
                }

                $this->_phpSheet->getPageSetup()->setScale($scale, false);
                $this->_phpSheet->getPageSetup()->setFitToPage((bool) $this->_isFitToPages);
                $this->_phpSheet->getPageSetup()->setFitToWidth($fitToWidth, false);
                $this->_phpSheet->getPageSetup()->setFitToHeight($fitToHeight, false);
            }

            // offset: 16; size: 8; header margin (IEEE 754 floating-point value)
            $marginHeader = self::_extractNumber(substr($recordData, 16, 8));
            $this->_phpSheet->getPageMargins()->setHeader($marginHeader);

            // offset: 24; size: 8; footer margin (IEEE 754 floating-point value)
            $marginFooter = self::_extractNumber(substr($recordData, 24, 8));
            $this->_phpSheet->getPageMargins()->setFooter($marginFooter);
        }
    }

    /**
     * PROTECT - Sheet protection (BIFF2 through BIFF8)
     *   if this record is omitted, then it also means no sheet protection
     */
    private function _readProtect()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if ($this->_readDataOnly) {
            return;
        }

        // offset: 0; size: 2;

        // bit 0, mask 0x01; 1 = sheet is protected
        $bool = (0x01 & self::_GetInt2d($recordData, 0)) >> 0;
        $this->_phpSheet->getProtection()->setSheet((bool)$bool);
    }

    /**
     * SCENPROTECT
     */
    private function _readScenProtect()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if ($this->_readDataOnly) {
            return;
        }

        // offset: 0; size: 2;

        // bit: 0, mask 0x01; 1 = scenarios are protected
        $bool = (0x01 & self::_GetInt2d($recordData, 0)) >> 0;

        $this->_phpSheet->getProtection()->setScenarios((bool)$bool);
    }

    /**
     * OBJECTPROTECT
     */
    private function _readObjectProtect()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if ($this->_readDataOnly) {
            return;
        }

        // offset: 0; size: 2;

        // bit: 0, mask 0x01; 1 = objects are protected
        $bool = (0x01 & self::_GetInt2d($recordData, 0)) >> 0;

        $this->_phpSheet->getProtection()->setObjects((bool)$bool);
    }

    /**
     * PASSWORD - Sheet protection (hashed) password (BIFF2 through BIFF8)
     */
    private function _readPassword()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 2; 16-bit hash value of password
            $password = strtoupper(dechex(self::_GetInt2d($recordData, 0))); // the hashed password
            $this->_phpSheet->getProtection()->setPassword($password, true);
        }
    }

    /**
     * Read DEFCOLWIDTH record
     */
    private function _readDefColWidth()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; default column width
        $width = self::_GetInt2d($recordData, 0);
        if ($width != 8) {
            $this->_phpSheet->getDefaultColumnDimension()->setWidth($width);
        }
    }

    /**
     * Read COLINFO record
     */
    private function _readColInfo()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 2; index to first column in range
            $fc = self::_GetInt2d($recordData, 0); // first column index

            // offset: 2; size: 2; index to last column in range
            $lc = self::_GetInt2d($recordData, 2); // first column index

            // offset: 4; size: 2; width of the column in 1/256 of the width of the zero character
            $width = self::_GetInt2d($recordData, 4);

            // offset: 6; size: 2; index to XF record for default column formatting
            $xfIndex = self::_GetInt2d($recordData, 6);

            // offset: 8; size: 2; option flags

                // bit: 0; mask: 0x0001; 1= columns are hidden
                $isHidden = (0x0001 & self::_GetInt2d($recordData, 8)) >> 0;

                // bit: 10-8; mask: 0x0700; outline level of the columns (0 = no outline)
                $level = (0x0700 & self::_GetInt2d($recordData, 8)) >> 8;

                // bit: 12; mask: 0x1000; 1 = collapsed
                $isCollapsed = (0x1000 & self::_GetInt2d($recordData, 8)) >> 12;

            // offset: 10; size: 2; not used

            for ($i = $fc; $i <= $lc; ++$i) {
                if ($lc == 255 || $lc == 256) {
                    $this->_phpSheet->getDefaultColumnDimension()->setWidth($width / 256);
                    break;
                }
                $this->_phpSheet->getColumnDimensionByColumn($i)->setWidth($width / 256);
                $this->_phpSheet->getColumnDimensionByColumn($i)->setVisible(!$isHidden);
                $this->_phpSheet->getColumnDimensionByColumn($i)->setOutlineLevel($level);
                $this->_phpSheet->getColumnDimensionByColumn($i)->setCollapsed($isCollapsed);
                $this->_phpSheet->getColumnDimensionByColumn($i)->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
            }
        }
    }

    /**
     * ROW
     *
     * This record contains the properties of a single row in a
     * sheet. Rows and cells in a sheet are divided into blocks
     * of 32 rows.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readRow()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 2; index of this row
            $r = self::_GetInt2d($recordData, 0);

            // offset: 2; size: 2; index to column of the first cell which is described by a cell record

            // offset: 4; size: 2; index to column of the last cell which is described by a cell record, increased by 1

            // offset: 6; size: 2;

                // bit: 14-0; mask: 0x7FFF; height of the row, in twips = 1/20 of a point
                $height = (0x7FFF & self::_GetInt2d($recordData, 6)) >> 0;

                // bit: 15: mask: 0x8000; 0 = row has custom height; 1= row has default height
                $useDefaultHeight = (0x8000 & self::_GetInt2d($recordData, 6)) >> 15;

                if (!$useDefaultHeight) {
                    $this->_phpSheet->getRowDimension($r + 1)->setRowHeight($height / 20);
                }

            // offset: 8; size: 2; not used

            // offset: 10; size: 2; not used in BIFF5-BIFF8

            // offset: 12; size: 4; option flags and default row formatting

                // bit: 2-0: mask: 0x00000007; outline level of the row
                $level = (0x00000007 & self::_GetInt4d($recordData, 12)) >> 0;
                $this->_phpSheet->getRowDimension($r + 1)->setOutlineLevel($level);

                // bit: 4; mask: 0x00000010; 1 = outline group start or ends here... and is collapsed
                $isCollapsed = (0x00000010 & self::_GetInt4d($recordData, 12)) >> 4;
                $this->_phpSheet->getRowDimension($r + 1)->setCollapsed($isCollapsed);

                // bit: 5; mask: 0x00000020; 1 = row is hidden
                $isHidden = (0x00000020 & self::_GetInt4d($recordData, 12)) >> 5;
                $this->_phpSheet->getRowDimension($r + 1)->setVisible(!$isHidden);

                // bit: 7; mask: 0x00000080; 1 = row has explicit format
                $hasExplicitFormat = (0x00000080 & self::_GetInt4d($recordData, 12)) >> 7;

                // bit: 27-16; mask: 0x0FFF0000; only applies when hasExplicitFormat = 1; index to XF record
                $xfIndex = (0x0FFF0000 & self::_GetInt4d($recordData, 12)) >> 16;

                if ($hasExplicitFormat) {
                    $this->_phpSheet->getRowDimension($r + 1)->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
                }
        }
    }

    /**
     * Read RK record
     * This record represents a cell that contains an RK value
     * (encoded integer or floating-point value). If a
     * floating-point value cannot be encoded to an RK value,
     * a NUMBER record will be written. This record replaces the
     * record INTEGER written in BIFF2.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readRk()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; index to row
        $row = self::_GetInt2d($recordData, 0);

        // offset: 2; size: 2; index to column
        $column = self::_GetInt2d($recordData, 2);
        $columnString = PHPExcel_Cell::stringFromColumnIndex($column);

        // Read cell?
        if ( !is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
            // offset: 4; size: 2; index to XF record
            $xfIndex = self::_GetInt2d($recordData, 4);

            // offset: 6; size: 4; RK value
            $rknum = self::_GetInt4d($recordData, 6);
            $numValue = self::_GetIEEE754($rknum);

            $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
            if (!$this->_readDataOnly) {
                // add style information
                $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
            }

            // add cell
            $cell->setValueExplicit($numValue, PHPExcel_Cell_DataType::TYPE_NUMERIC);
        }
    }

    /**
     * Read LABELSST record
     * This record represents a cell that contains a string. It
     * replaces the LABEL record and RSTRING record used in
     * BIFF2-BIFF5.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readLabelSst()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; index to row
        $row = self::_GetInt2d($recordData, 0);

        // offset: 2; size: 2; index to column
        $column = self::_GetInt2d($recordData, 2);
        $columnString = PHPExcel_Cell::stringFromColumnIndex($column);

        // Read cell?
        if ( !is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
            // offset: 4; size: 2; index to XF record
            $xfIndex = self::_GetInt2d($recordData, 4);

            // offset: 6; size: 4; index to SST record
            $index = self::_GetInt4d($recordData, 6);

            // add cell
            if (($fmtRuns = $this->_sst[$index]['fmtRuns']) && !$this->_readDataOnly) {
                // then we should treat as rich text
                $richText = new PHPExcel_RichText();
                $charPos = 0;
                $sstCount = count($this->_sst[$index]['fmtRuns']);
                for ($i = 0; $i <= $sstCount; ++$i) {
                    if (isset($fmtRuns[$i])) {
                        $text = PHPExcel_Shared_String::Substring($this->_sst[$index]['value'], $charPos, $fmtRuns[$i]['charPos'] - $charPos);
                        $charPos = $fmtRuns[$i]['charPos'];
                    } else {
                        $text = PHPExcel_Shared_String::Substring($this->_sst[$index]['value'], $charPos, PHPExcel_Shared_String::CountCharacters($this->_sst[$index]['value']));
                    }

                    if (PHPExcel_Shared_String::CountCharacters($text) > 0) {
                        if ($i == 0) { // first text run, no style
                            $richText->createText($text);
                        } else {
                            $textRun = $richText->createTextRun($text);
                            if (isset($fmtRuns[$i - 1])) {
                                if ($fmtRuns[$i - 1]['fontIndex'] < 4) {
                                    $fontIndex = $fmtRuns[$i - 1]['fontIndex'];
                                } else {
                                    // this has to do with that index 4 is omitted in all BIFF versions for some strange reason
                                    // check the OpenOffice documentation of the FONT record
                                    $fontIndex = $fmtRuns[$i - 1]['fontIndex'] - 1;
                                }
                                $textRun->setFont(clone $this->_objFonts[$fontIndex]);
                            }
                        }
                    }
                }
                $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
                $cell->setValueExplicit($richText, PHPExcel_Cell_DataType::TYPE_STRING);
            } else {
                $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
                $cell->setValueExplicit($this->_sst[$index]['value'], PHPExcel_Cell_DataType::TYPE_STRING);
            }

            if (!$this->_readDataOnly) {
                // add style information
                $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
            }
        }
    }

    /**
     * Read MULRK record
     * This record represents a cell range containing RK value
     * cells. All cells are located in the same row.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readMulRk()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; index to row
        $row = self::_GetInt2d($recordData, 0);

        // offset: 2; size: 2; index to first column
        $colFirst = self::_GetInt2d($recordData, 2);

        // offset: var; size: 2; index to last column
        $colLast = self::_GetInt2d($recordData, $length - 2);
        $columns = $colLast - $colFirst + 1;

        // offset within record data
        $offset = 4;

        for ($i = 0; $i < $columns; ++$i) {
            $columnString = PHPExcel_Cell::stringFromColumnIndex($colFirst + $i);

            // Read cell?
            if ( !is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {

                // offset: var; size: 2; index to XF record
                $xfIndex = self::_GetInt2d($recordData, $offset);

                // offset: var; size: 4; RK value
                $numValue = self::_GetIEEE754(self::_GetInt4d($recordData, $offset + 2));
                $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
                if (!$this->_readDataOnly) {
                    // add style
                    $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
                }

                // add cell value
                $cell->setValueExplicit($numValue, PHPExcel_Cell_DataType::TYPE_NUMERIC);
            }

            $offset += 6;
        }
    }

    /**
     * Read NUMBER record
     * This record represents a cell that contains a
     * floating-point value.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readNumber()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; index to row
        $row = self::_GetInt2d($recordData, 0);

        // offset: 2; size 2; index to column
        $column = self::_GetInt2d($recordData, 2);
        $columnString = PHPExcel_Cell::stringFromColumnIndex($column);

        // Read cell?
        if ( !is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
            // offset 4; size: 2; index to XF record
            $xfIndex = self::_GetInt2d($recordData, 4);

            $numValue = self::_extractNumber(substr($recordData, 6, 8));

            $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
            if (!$this->_readDataOnly) {
                // add cell style
                $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
            }

            // add cell value
            $cell->setValueExplicit($numValue, PHPExcel_Cell_DataType::TYPE_NUMERIC);
        }
    }

    /**
     * Read FORMULA record + perhaps a following STRING record if formula result is a string
     * This record contains the token array and the result of a
     * formula cell.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readFormula()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; row index
        $row = self::_GetInt2d($recordData, 0);

        // offset: 2; size: 2; col index
        $column = self::_GetInt2d($recordData, 2);
        $columnString = PHPExcel_Cell::stringFromColumnIndex($column);

        // offset: 20: size: variable; formula structure
        $formulaStructure = substr($recordData, 20);

        // offset: 14: size: 2; option flags, recalculate always, recalculate on open etc.
        $options = self::_GetInt2d($recordData, 14);

        // bit: 0; mask: 0x0001; 1 = recalculate always
        // bit: 1; mask: 0x0002; 1 = calculate on open
        // bit: 2; mask: 0x0008; 1 = part of a shared formula
        $isPartOfSharedFormula = (bool) (0x0008 & $options);

        // WARNING:
        // We can apparently not rely on $isPartOfSharedFormula. Even when $isPartOfSharedFormula = true
        // the formula data may be ordinary formula data, therefore we need to check
        // explicitly for the tExp token (0x01)
        $isPartOfSharedFormula = $isPartOfSharedFormula && ord($formulaStructure{2}) == 0x01;

        if ($isPartOfSharedFormula) {
            // part of shared formula which means there will be a formula with a tExp token and nothing else
            // get the base cell, grab tExp token
            $baseRow = self::_GetInt2d($formulaStructure, 3);
            $baseCol = self::_GetInt2d($formulaStructure, 5);
            $this->_baseCell = PHPExcel_Cell::stringFromColumnIndex($baseCol). ($baseRow + 1);
        }

        // Read cell?
        if ( !is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {

            if ($isPartOfSharedFormula) {
                // formula is added to this cell after the sheet has been read
                $this->_sharedFormulaParts[$columnString . ($row + 1)] = $this->_baseCell;
            }

            // offset: 16: size: 4; not used

            // offset: 4; size: 2; XF index
            $xfIndex = self::_GetInt2d($recordData, 4);

            // offset: 6; size: 8; result of the formula
            if ( (ord($recordData{6}) == 0)
                && (ord($recordData{12}) == 255)
                && (ord($recordData{13}) == 255) ) {

                // String formula. Result follows in appended STRING record
                $dataType = PHPExcel_Cell_DataType::TYPE_STRING;

                // read possible SHAREDFMLA record
                $code = self::_GetInt2d($this->_data, $this->_pos);
                if ($code == self::XLS_Type_SHAREDFMLA) {
                    $this->_readSharedFmla();
                }

                // read STRING record
                $value = $this->_readString();

            } elseif ((ord($recordData{6}) == 1)
                && (ord($recordData{12}) == 255)
                && (ord($recordData{13}) == 255)) {

                // Boolean formula. Result is in +2; 0=false, 1=true
                $dataType = PHPExcel_Cell_DataType::TYPE_BOOL;
                $value = (bool) ord($recordData{8});

            } elseif ((ord($recordData{6}) == 2)
                && (ord($recordData{12}) == 255)
                && (ord($recordData{13}) == 255)) {

                // Error formula. Error code is in +2
                $dataType = PHPExcel_Cell_DataType::TYPE_ERROR;
                $value = self::_mapErrorCode(ord($recordData{8}));

            } elseif ((ord($recordData{6}) == 3)
                && (ord($recordData{12}) == 255)
                && (ord($recordData{13}) == 255)) {

                // Formula result is a null string
                $dataType = PHPExcel_Cell_DataType::TYPE_NULL;
                $value = '';

            } else {

                // forumla result is a number, first 14 bytes like _NUMBER record
                $dataType = PHPExcel_Cell_DataType::TYPE_NUMERIC;
                $value = self::_extractNumber(substr($recordData, 6, 8));

            }

            $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
            if (!$this->_readDataOnly) {
                // add cell style
                $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
            }

            // store the formula
            if (!$isPartOfSharedFormula) {
                // not part of shared formula
                // add cell value. If we can read formula, populate with formula, otherwise just used cached value
                try {
                    if ($this->_version != self::XLS_BIFF8) {
                        throw new Exception('Not BIFF8. Can only read BIFF8 formulas');
                    }
                    $formula = $this->_getFormulaFromStructure($formulaStructure); // get formula in human language
                    $cell->setValueExplicit('=' . $formula, PHPExcel_Cell_DataType::TYPE_FORMULA);

                } catch (Exception $e) {
                    $cell->setValueExplicit($value, $dataType);
                }
            } else {
                if ($this->_version == self::XLS_BIFF8) {
                    // do nothing at this point, formula id added later in the code
                } else {
                    $cell->setValueExplicit($value, $dataType);
                }
            }

            // store the cached calculated value
            $cell->setCalculatedValue($value);
        }
    }

    /**
     * Read a SHAREDFMLA record. This function just stores the binary shared formula in the reader,
     * which usually contains relative references.
     * These will be used to construct the formula in each shared formula part after the sheet is read.
     */
    private function _readSharedFmla()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0, size: 6; cell range address of the area used by the shared formula, not used for anything
        $cellRange = substr($recordData, 0, 6);
        $cellRange = $this->_readBIFF5CellRangeAddressFixed($cellRange); // note: even BIFF8 uses BIFF5 syntax

        // offset: 6, size: 1; not used

        // offset: 7, size: 1; number of existing FORMULA records for this shared formula
        $no = ord($recordData{7});

        // offset: 8, size: var; Binary token array of the shared formula
        $formula = substr($recordData, 8);

        // at this point we only store the shared formula for later use
        $this->_sharedFormulas[$this->_baseCell] = $formula;

    }

    /**
     * Read a STRING record from current stream position and advance the stream pointer to next record
     * This record is used for storing result from FORMULA record when it is a string, and
     * it occurs directly after the FORMULA record
     *
     * @return string The string contents as UTF-8
     */
    private function _readString()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if ($this->_version == self::XLS_BIFF8) {
            $string = self::_readUnicodeStringLong($recordData);
            $value = $string['value'];
        } else {
            $string = $this->_readByteStringLong($recordData);
            $value = $string['value'];
        }

        return $value;
    }

    /**
     * Read BOOLERR record
     * This record represents a Boolean value or error value
     * cell.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readBoolErr()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; row index
        $row = self::_GetInt2d($recordData, 0);

        // offset: 2; size: 2; column index
        $column = self::_GetInt2d($recordData, 2);
        $columnString = PHPExcel_Cell::stringFromColumnIndex($column);

        // Read cell?
        if ( !is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
            // offset: 4; size: 2; index to XF record
            $xfIndex = self::_GetInt2d($recordData, 4);

            // offset: 6; size: 1; the boolean value or error value
            $boolErr = ord($recordData{6});

            // offset: 7; size: 1; 0=boolean; 1=error
            $isError = ord($recordData{7});

            $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
            switch ($isError) {
                case 0: // boolean
                    $value = (bool) $boolErr;

                    // add cell value
                    $cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_BOOL);
                    break;

                case 1: // error type
                    $value = self::_mapErrorCode($boolErr);

                    // add cell value
                    $cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_ERROR);
                    break;
            }

            if (!$this->_readDataOnly) {
                // add cell style
                $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
            }
        }
    }

    /**
     * Read MULBLANK record
     * This record represents a cell range of empty cells. All
     * cells are located in the same row
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readMulBlank()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; index to row
        $row = self::_GetInt2d($recordData, 0);

        // offset: 2; size: 2; index to first column
        $fc = self::_GetInt2d($recordData, 2);

        // offset: 4; size: 2 x nc; list of indexes to XF records
        // add style information
        if (!$this->_readDataOnly) {
            for ($i = 0; $i < $length / 2 - 3; ++$i) {
                $columnString = PHPExcel_Cell::stringFromColumnIndex($fc + $i);

                // Read cell?
                if ( !is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
                    $xfIndex = self::_GetInt2d($recordData, 4 + 2 * $i);
                    $this->_phpSheet->getCell($columnString . ($row + 1))->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
                }
            }
        }

        // offset: 6; size 2; index to last column (not needed)
    }

    /**
     * Read LABEL record
     * This record represents a cell that contains a string. In
     * BIFF8 it is usually replaced by the LABELSST record.
     * Excel still uses this record, if it copies unformatted
     * text cells to the clipboard.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readLabel()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; index to row
        $row = self::_GetInt2d($recordData, 0);

        // offset: 2; size: 2; index to column
        $column = self::_GetInt2d($recordData, 2);
        $columnString = PHPExcel_Cell::stringFromColumnIndex($column);

        // Read cell?
        if ( !is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
            // offset: 4; size: 2; XF index
            $xfIndex = self::_GetInt2d($recordData, 4);

            // add cell value
            // todo: what if string is very long? continue record
            if ($this->_version == self::XLS_BIFF8) {
                $string = self::_readUnicodeStringLong(substr($recordData, 6));
                $value = $string['value'];
            } else {
                $string = $this->_readByteStringLong(substr($recordData, 6));
                $value = $string['value'];
            }
            $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
            $cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_STRING);

            if (!$this->_readDataOnly) {
                // add cell style
                $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
            }
        }
    }

    /**
     * Read BLANK record
     */
    private function _readBlank()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; row index
        $row = self::_GetInt2d($recordData, 0);

        // offset: 2; size: 2; col index
        $col = self::_GetInt2d($recordData, 2);
        $columnString = PHPExcel_Cell::stringFromColumnIndex($col);

        // Read cell?
        if ( !is_null($this->getReadFilter()) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
            // offset: 4; size: 2; XF index
            $xfIndex = self::_GetInt2d($recordData, 4);

            // add style information
            if (!$this->_readDataOnly) {
                $this->_phpSheet->getCell($columnString . ($row + 1))->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
            }
        }

    }

    /**
     * Read MSODRAWING record
     */
    private function _readMsoDrawing()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);

        // get spliced record data
        $splicedRecordData = $this->_getSplicedRecordData();
        $recordData = $splicedRecordData['recordData'];

        $this->_drawingData .= $recordData;
    }

    /**
     * Read OBJ record
     */
    private function _readObj()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if ($this->_readDataOnly || $this->_version != self::XLS_BIFF8) {
            return;
        }

        // recordData consists of an array of subrecords looking like this:
        //    ft: 2 bytes; ftCmo type (0x15)
        //    cb: 2 bytes; size in bytes of ftCmo data
        //    ot: 2 bytes; Object Type
        //    id: 2 bytes; Object id number
        //    grbit: 2 bytes; Option Flags
        //    data: var; subrecord data

        // for now, we are just interested in the second subrecord containing the object type
        $ftCmoType    = self::_GetInt2d($recordData, 0);
        $cbCmoSize    = self::_GetInt2d($recordData, 2);
        $otObjType    = self::_GetInt2d($recordData, 4);
        $idObjID    = self::_GetInt2d($recordData, 6);
        $grbitOpts    = self::_GetInt2d($recordData, 6);

        $this->_objs[] = array(
            'ftCmoType'    => $ftCmoType,
            'cbCmoSize'    => $cbCmoSize,
            'otObjType'    => $otObjType,
            'idObjID'    => $idObjID,
            'grbitOpts'    => $grbitOpts
        );
        $this->textObjRef = $idObjID;

//        echo '<b>_readObj()</b><br />';
//        var_dump(end($this->_objs));
//        echo '<br />';
    }

    /**
     * Read WINDOW2 record
     */
    private function _readWindow2()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; option flags
        $options = self::_GetInt2d($recordData, 0);

        // bit: 1; mask: 0x0002; 0 = do not show gridlines, 1 = show gridlines
        $showGridlines = (bool) ((0x0002 & $options) >> 1);
        $this->_phpSheet->setShowGridlines($showGridlines);

        // bit: 2; mask: 0x0004; 0 = do not show headers, 1 = show headers
        $showRowColHeaders = (bool) ((0x0004 & $options) >> 2);
        $this->_phpSheet->setShowRowColHeaders($showRowColHeaders);

        // bit: 3; mask: 0x0008; 0 = panes are not frozen, 1 = panes are frozen
        $this->_frozen = (bool) ((0x0008 & $options) >> 3);

        // bit: 6; mask: 0x0040; 0 = columns from left to right, 1 = columns from right to left
        $this->_phpSheet->setRightToLeft((bool)((0x0040 & $options) >> 6));

        // bit: 10; mask: 0x0400; 0 = sheet not active, 1 = sheet active
        $isActive = (bool) ((0x0400 & $options) >> 10);
        if ($isActive) {
            $this->_phpExcel->setActiveSheetIndex($this->_phpExcel->getIndex($this->_phpSheet));
        }
    }

    /**
     * Read SCL record
     */
    private function _readScl()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // offset: 0; size: 2; numerator of the view magnification
        $numerator = self::_GetInt2d($recordData, 0);

        // offset: 2; size: 2; numerator of the view magnification
        $denumerator = self::_GetInt2d($recordData, 2);

        // set the zoom scale (in percent)
        $this->_phpSheet->getSheetView()->setZoomScale($numerator * 100 / $denumerator);
    }

    /**
     * Read PANE record
     */
    private function _readPane()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 2; position of vertical split
            $px = self::_GetInt2d($recordData, 0);

            // offset: 2; size: 2; position of horizontal split
            $py = self::_GetInt2d($recordData, 2);

            if ($this->_frozen) {
                // frozen panes
                $this->_phpSheet->freezePane(PHPExcel_Cell::stringFromColumnIndex($px) . ($py + 1));
            } else {
                // unfrozen panes; split windows; not supported by PHPExcel core
            }
        }
    }

    /**
     * Read SELECTION record. There is one such record for each pane in the sheet.
     */
    private function _readSelection()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 1; pane identifier
            $paneId = ord($recordData{0});

            // offset: 1; size: 2; index to row of the active cell
            $r = self::_GetInt2d($recordData, 1);

            // offset: 3; size: 2; index to column of the active cell
            $c = self::_GetInt2d($recordData, 3);

            // offset: 5; size: 2; index into the following cell range list to the
            //  entry that contains the active cell
            $index = self::_GetInt2d($recordData, 5);

            // offset: 7; size: var; cell range address list containing all selected cell ranges
            $data = substr($recordData, 7);
            $cellRangeAddressList = $this->_readBIFF5CellRangeAddressList($data); // note: also BIFF8 uses BIFF5 syntax

            $selectedCells = $cellRangeAddressList['cellRangeAddresses'][0];

            // first row '1' + last row '16384' indicates that full column is selected (apparently also in BIFF8!)
            if (preg_match('/^([A-Z]+1\:[A-Z]+)16384$/', $selectedCells)) {
                $selectedCells = preg_replace('/^([A-Z]+1\:[A-Z]+)16384$/', '${1}1048576', $selectedCells);
            }

            // first row '1' + last row '65536' indicates that full column is selected
            if (preg_match('/^([A-Z]+1\:[A-Z]+)65536$/', $selectedCells)) {
                $selectedCells = preg_replace('/^([A-Z]+1\:[A-Z]+)65536$/', '${1}1048576', $selectedCells);
            }

            // first column 'A' + last column 'IV' indicates that full row is selected
            if (preg_match('/^(A[0-9]+\:)IV([0-9]+)$/', $selectedCells)) {
                $selectedCells = preg_replace('/^(A[0-9]+\:)IV([0-9]+)$/', '${1}XFD${2}', $selectedCells);
            }

            $this->_phpSheet->setSelectedCells($selectedCells);
        }
    }

    private function _includeCellRangeFiltered($cellRangeAddress)
    {
        $includeCellRange = true;
        if (!is_null($this->getReadFilter())) {
            $includeCellRange = false;
            $rangeBoundaries = PHPExcel_Cell::getRangeBoundaries($cellRangeAddress);
            $rangeBoundaries[1][0]++;
            for ($row = $rangeBoundaries[0][1]; $row <= $rangeBoundaries[1][1]; $row++) {
                for ($column = $rangeBoundaries[0][0]; $column != $rangeBoundaries[1][0]; $column++) {
                    if ($this->getReadFilter()->readCell($column, $row, $this->_phpSheet->getTitle())) {
                        $includeCellRange = true;
                        break 2;
                    }
                }
            }
        }
        return $includeCellRange;
    }

    /**
     * MERGEDCELLS
     *
     * This record contains the addresses of merged cell ranges
     * in the current sheet.
     *
     * --    "OpenOffice.org's Documentation of the Microsoft
     *         Excel File Format"
     */
    private function _readMergedCells()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) {
            $cellRangeAddressList = $this->_readBIFF8CellRangeAddressList($recordData);
            foreach ($cellRangeAddressList['cellRangeAddresses'] as $cellRangeAddress) {
                if ($this->_includeCellRangeFiltered($cellRangeAddress)) {
                    $this->_phpSheet->mergeCells($cellRangeAddress);
                }
            }
        }
    }

    /**
     * Read HYPERLINK record
     */
    private function _readHyperLink()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer forward to next record
        $this->_pos += 4 + $length;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 8; cell range address of all cells containing this hyperlink
            try {
                $cellRange = $this->_readBIFF8CellRangeAddressFixed($recordData, 0, 8);
            } catch (Exception $e) {
                return;
            }

            // offset: 8, size: 16; GUID of StdLink

            // offset: 24, size: 4; unknown value

            // offset: 28, size: 4; option flags

                // bit: 0; mask: 0x00000001; 0 = no link or extant, 1 = file link or URL
                $isFileLinkOrUrl = (0x00000001 & self::_GetInt2d($recordData, 28)) >> 0;

                // bit: 1; mask: 0x00000002; 0 = relative path, 1 = absolute path or URL
                $isAbsPathOrUrl = (0x00000001 & self::_GetInt2d($recordData, 28)) >> 1;

                // bit: 2 (and 4); mask: 0x00000014; 0 = no description
                $hasDesc = (0x00000014 & self::_GetInt2d($recordData, 28)) >> 2;

                // bit: 3; mask: 0x00000008; 0 = no text, 1 = has text
                $hasText = (0x00000008 & self::_GetInt2d($recordData, 28)) >> 3;

                // bit: 7; mask: 0x00000080; 0 = no target frame, 1 = has target frame
                $hasFrame = (0x00000080 & self::_GetInt2d($recordData, 28)) >> 7;

                // bit: 8; mask: 0x00000100; 0 = file link or URL, 1 = UNC path (inc. server name)
                $isUNC = (0x00000100 & self::_GetInt2d($recordData, 28)) >> 8;

            // offset within record data
            $offset = 32;

            if ($hasDesc) {
                // offset: 32; size: var; character count of description text
                $dl = self::_GetInt4d($recordData, 32);
                // offset: 36; size: var; character array of description text, no Unicode string header, always 16-bit characters, zero terminated
                $desc = self::_encodeUTF16(substr($recordData, 36, 2 * ($dl - 1)), false);
                $offset += 4 + 2 * $dl;
            }
            if ($hasFrame) {
                $fl = self::_GetInt4d($recordData, $offset);
                $offset += 4 + 2 * $fl;
            }

            // detect type of hyperlink (there are 4 types)
            $hyperlinkType = null;

            if ($isUNC) {
                $hyperlinkType = 'UNC';
            } else if (!$isFileLinkOrUrl) {
                $hyperlinkType = 'workbook';
            } else if (ord($recordData{$offset}) == 0x03) {
                $hyperlinkType = 'local';
            } else if (ord($recordData{$offset}) == 0xE0) {
                $hyperlinkType = 'URL';
            }

            switch ($hyperlinkType) {
            case 'URL':
                // section 5.58.2: Hyperlink containing a URL
                // e.g. http://example.org/index.php

                // offset: var; size: 16; GUID of URL Moniker
                $offset += 16;
                // offset: var; size: 4; size (in bytes) of character array of the URL including trailing zero word
                $us = self::_GetInt4d($recordData, $offset);
                $offset += 4;
                // offset: var; size: $us; character array of the URL, no Unicode string header, always 16-bit characters, zero-terminated
                $url = self::_encodeUTF16(substr($recordData, $offset, $us - 2), false);
                $url .= $hasText ? '#' : '';
                $offset += $us;
                break;

            case 'local':
                // section 5.58.3: Hyperlink to local file
                // examples:
                //   mydoc.txt
                //   ../../somedoc.xls#Sheet!A1

                // offset: var; size: 16; GUI of File Moniker
                $offset += 16;

                // offset: var; size: 2; directory up-level count.
                $upLevelCount = self::_GetInt2d($recordData, $offset);
                $offset += 2;

                // offset: var; size: 4; character count of the shortened file path and name, including trailing zero word
                $sl = self::_GetInt4d($recordData, $offset);
                $offset += 4;

                // offset: var; size: sl; character array of the shortened file path and name in 8.3-DOS-format (compressed Unicode string)
                $shortenedFilePath = substr($recordData, $offset, $sl);
                $shortenedFilePath = self::_encodeUTF16($shortenedFilePath, true);
                $shortenedFilePath = substr($shortenedFilePath, 0, -1); // remove trailing zero

                $offset += $sl;

                // offset: var; size: 24; unknown sequence
                $offset += 24;

                // extended file path
                // offset: var; size: 4; size of the following file link field including string lenth mark
                $sz = self::_GetInt4d($recordData, $offset);
                $offset += 4;

                // only present if $sz > 0
                if ($sz > 0) {
                    // offset: var; size: 4; size of the character array of the extended file path and name
                    $xl = self::_GetInt4d($recordData, $offset);
                    $offset += 4;

                    // offset: var; size 2; unknown
                    $offset += 2;

                    // offset: var; size $xl; character array of the extended file path and name.
                    $extendedFilePath = substr($recordData, $offset, $xl);
                    $extendedFilePath = self::_encodeUTF16($extendedFilePath, false);
                    $offset += $xl;
                }

                // construct the path
                $url = str_repeat('..\\', $upLevelCount);
                $url .= ($sz > 0) ?
                    $extendedFilePath : $shortenedFilePath; // use extended path if available
                $url .= $hasText ? '#' : '';

                break;


            case 'UNC':
                // section 5.58.4: Hyperlink to a File with UNC (Universal Naming Convention) Path
                // todo: implement
                return;

            case 'workbook':
                // section 5.58.5: Hyperlink to the Current Workbook
                // e.g. Sheet2!B1:C2, stored in text mark field
                $url = 'sheet://';
                break;

            default:
                return;

            }

            if ($hasText) {
                // offset: var; size: 4; character count of text mark including trailing zero word
                $tl = self::_GetInt4d($recordData, $offset);
                $offset += 4;
                // offset: var; size: var; character array of the text mark without the # sign, no Unicode header, always 16-bit characters, zero-terminated
                $text = self::_encodeUTF16(substr($recordData, $offset, 2 * ($tl - 1)), false);
                $url .= $text;
            }

            // apply the hyperlink to all the relevant cells
            foreach (PHPExcel_Cell::extractAllCellReferencesInRange($cellRange) as $coordinate) {
                $this->_phpSheet->getCell($coordinate)->getHyperLink()->setUrl($url);
            }
        }
    }

    /**
     * Read DATAVALIDATIONS record
     */
    private function _readDataValidations()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer forward to next record
        $this->_pos += 4 + $length;
    }

    /**
     * Read DATAVALIDATION record
     */
    private function _readDataValidation()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer forward to next record
        $this->_pos += 4 + $length;

        if ($this->_readDataOnly) {
            return;
        }

        // offset: 0; size: 4; Options
        $options = self::_GetInt4d($recordData, 0);

        // bit: 0-3; mask: 0x0000000F; type
        $type = (0x0000000F & $options) >> 0;
        switch ($type) {
            case 0x00:    $type = PHPExcel_Cell_DataValidation::TYPE_NONE;        break;
            case 0x01:    $type = PHPExcel_Cell_DataValidation::TYPE_WHOLE;        break;
            case 0x02:    $type = PHPExcel_Cell_DataValidation::TYPE_DECIMAL;        break;
            case 0x03:    $type = PHPExcel_Cell_DataValidation::TYPE_LIST;        break;
            case 0x04:    $type = PHPExcel_Cell_DataValidation::TYPE_DATE;        break;
            case 0x05:    $type = PHPExcel_Cell_DataValidation::TYPE_TIME;        break;
            case 0x06:    $type = PHPExcel_Cell_DataValidation::TYPE_TEXTLENGTH;    break;
            case 0x07:    $type = PHPExcel_Cell_DataValidation::TYPE_CUSTOM;        break;
        }

        // bit: 4-6; mask: 0x00000070; error type
        $errorStyle = (0x00000070 & $options) >> 4;
        switch ($errorStyle) {
            case 0x00:    $errorStyle = PHPExcel_Cell_DataValidation::STYLE_STOP;            break;
            case 0x01:    $errorStyle = PHPExcel_Cell_DataValidation::STYLE_WARNING;        break;
            case 0x02:    $errorStyle = PHPExcel_Cell_DataValidation::STYLE_INFORMATION;    break;
        }

        // bit: 7; mask: 0x00000080; 1= formula is explicit (only applies to list)
        // I have only seen cases where this is 1
        $explicitFormula = (0x00000080 & $options) >> 7;

        // bit: 8; mask: 0x00000100; 1= empty cells allowed
        $allowBlank = (0x00000100 & $options) >> 8;

        // bit: 9; mask: 0x00000200; 1= suppress drop down arrow in list type validity
        $suppressDropDown = (0x00000200 & $options) >> 9;

        // bit: 18; mask: 0x00040000; 1= show prompt box if cell selected
        $showInputMessage = (0x00040000 & $options) >> 18;

        // bit: 19; mask: 0x00080000; 1= show error box if invalid values entered
        $showErrorMessage = (0x00080000 & $options) >> 19;

        // bit: 20-23; mask: 0x00F00000; condition operator
        $operator = (0x00F00000 & $options) >> 20;
        switch ($operator) {
            case 0x00: $operator = PHPExcel_Cell_DataValidation::OPERATOR_BETWEEN            ;    break;
            case 0x01: $operator = PHPExcel_Cell_DataValidation::OPERATOR_NOTBETWEEN        ;    break;
            case 0x02: $operator = PHPExcel_Cell_DataValidation::OPERATOR_EQUAL                ;    break;
            case 0x03: $operator = PHPExcel_Cell_DataValidation::OPERATOR_NOTEQUAL            ;    break;
            case 0x04: $operator = PHPExcel_Cell_DataValidation::OPERATOR_GREATERTHAN        ;    break;
            case 0x05: $operator = PHPExcel_Cell_DataValidation::OPERATOR_LESSTHAN            ;    break;
            case 0x06: $operator = PHPExcel_Cell_DataValidation::OPERATOR_GREATERTHANOREQUAL;    break;
            case 0x07: $operator = PHPExcel_Cell_DataValidation::OPERATOR_LESSTHANOREQUAL    ;    break;
        }

        // offset: 4; size: var; title of the prompt box
        $offset = 4;
        $string = self::_readUnicodeStringLong(substr($recordData, $offset));
        $promptTitle = $string['value'] !== chr(0) ?
            $string['value'] : '';
        $offset += $string['size'];

        // offset: var; size: var; title of the error box
        $string = self::_readUnicodeStringLong(substr($recordData, $offset));
        $errorTitle = $string['value'] !== chr(0) ?
            $string['value'] : '';
        $offset += $string['size'];

        // offset: var; size: var; text of the prompt box
        $string = self::_readUnicodeStringLong(substr($recordData, $offset));
        $prompt = $string['value'] !== chr(0) ?
            $string['value'] : '';
        $offset += $string['size'];

        // offset: var; size: var; text of the error box
        $string = self::_readUnicodeStringLong(substr($recordData, $offset));
        $error = $string['value'] !== chr(0) ?
            $string['value'] : '';
        $offset += $string['size'];

        // offset: var; size: 2; size of the formula data for the first condition
        $sz1 = self::_GetInt2d($recordData, $offset);
        $offset += 2;

        // offset: var; size: 2; not used
        $offset += 2;

        // offset: var; size: $sz1; formula data for first condition (without size field)
        $formula1 = substr($recordData, $offset, $sz1);
        $formula1 = pack('v', $sz1) . $formula1; // prepend the length
        try {
            $formula1 = $this->_getFormulaFromStructure($formula1);

            // in list type validity, null characters are used as item separators
            if ($type == PHPExcel_Cell_DataValidation::TYPE_LIST) {
                $formula1 = str_replace(chr(0), ',', $formula1);
            }
        } catch (Exception $e) {
            return;
        }
        $offset += $sz1;

        // offset: var; size: 2; size of the formula data for the first condition
        $sz2 = self::_GetInt2d($recordData, $offset);
        $offset += 2;

        // offset: var; size: 2; not used
        $offset += 2;

        // offset: var; size: $sz2; formula data for second condition (without size field)
        $formula2 = substr($recordData, $offset, $sz2);
        $formula2 = pack('v', $sz2) . $formula2; // prepend the length
        try {
            $formula2 = $this->_getFormulaFromStructure($formula2);
        } catch (Exception $e) {
            return;
        }
        $offset += $sz2;

        // offset: var; size: var; cell range address list with
        $cellRangeAddressList = $this->_readBIFF8CellRangeAddressList(substr($recordData, $offset));
        $cellRangeAddresses = $cellRangeAddressList['cellRangeAddresses'];

        foreach ($cellRangeAddresses as $cellRange) {
            $stRange = $this->_phpSheet->shrinkRangeToFit($cellRange);
            $stRange = PHPExcel_Cell::extractAllCellReferencesInRange($stRange);
            foreach ($stRange as $coordinate) {
                $objValidation = $this->_phpSheet->getCell($coordinate)->getDataValidation();
                $objValidation->setType($type);
                $objValidation->setErrorStyle($errorStyle);
                $objValidation->setAllowBlank((bool)$allowBlank);
                $objValidation->setShowInputMessage((bool)$showInputMessage);
                $objValidation->setShowErrorMessage((bool)$showErrorMessage);
                $objValidation->setShowDropDown(!$suppressDropDown);
                $objValidation->setOperator($operator);
                $objValidation->setErrorTitle($errorTitle);
                $objValidation->setError($error);
                $objValidation->setPromptTitle($promptTitle);
                $objValidation->setPrompt($prompt);
                $objValidation->setFormula1($formula1);
                $objValidation->setFormula2($formula2);
            }
        }

    }

    /**
     * Read SHEETLAYOUT record. Stores sheet tab color information.
     */
    private function _readSheetLayout()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // local pointer in record data
        $offset = 0;

        if (!$this->_readDataOnly) {
            // offset: 0; size: 2; repeated record identifier 0x0862

            // offset: 2; size: 10; not used

            // offset: 12; size: 4; size of record data
            // Excel 2003 uses size of 0x14 (documented), Excel 2007 uses size of 0x28 (not documented?)
            $sz = self::_GetInt4d($recordData, 12);

            switch ($sz) {
                case 0x14:
                    // offset: 16; size: 2; color index for sheet tab
                    $colorIndex = self::_GetInt2d($recordData, 16);
                    $color = self::_readColor($colorIndex,$this->_palette,$this->_version);
                    $this->_phpSheet->getTabColor()->setRGB($color['rgb']);
                    break;

                case 0x28:
                    // TODO: Investigate structure for .xls SHEETLAYOUT record as saved by MS Office Excel 2007
                    return;
                    break;
            }
        }
    }

    /**
     * Read SHEETPROTECTION record (FEATHEADR)
     */
    private function _readSheetProtection()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        if ($this->_readDataOnly) {
            return;
        }

        // offset: 0; size: 2; repeated record header

        // offset: 2; size: 2; FRT cell reference flag (=0 currently)

        // offset: 4; size: 8; Currently not used and set to 0

        // offset: 12; size: 2; Shared feature type index (2=Enhanced Protetion, 4=SmartTag)
        $isf = self::_GetInt2d($recordData, 12);
        if ($isf != 2) {
            return;
        }

        // offset: 14; size: 1; =1 since this is a feat header

        // offset: 15; size: 4; size of rgbHdrSData

        // rgbHdrSData, assume "Enhanced Protection"
        // offset: 19; size: 2; option flags
        $options = self::_GetInt2d($recordData, 19);

        // bit: 0; mask 0x0001; 1 = user may edit objects, 0 = users must not edit objects
        $bool = (0x0001 & $options) >> 0;
        $this->_phpSheet->getProtection()->setObjects(!$bool);

        // bit: 1; mask 0x0002; edit scenarios
        $bool = (0x0002 & $options) >> 1;
        $this->_phpSheet->getProtection()->setScenarios(!$bool);

        // bit: 2; mask 0x0004; format cells
        $bool = (0x0004 & $options) >> 2;
        $this->_phpSheet->getProtection()->setFormatCells(!$bool);

        // bit: 3; mask 0x0008; format columns
        $bool = (0x0008 & $options) >> 3;
        $this->_phpSheet->getProtection()->setFormatColumns(!$bool);

        // bit: 4; mask 0x0010; format rows
        $bool = (0x0010 & $options) >> 4;
        $this->_phpSheet->getProtection()->setFormatRows(!$bool);

        // bit: 5; mask 0x0020; insert columns
        $bool = (0x0020 & $options) >> 5;
        $this->_phpSheet->getProtection()->setInsertColumns(!$bool);

        // bit: 6; mask 0x0040; insert rows
        $bool = (0x0040 & $options) >> 6;
        $this->_phpSheet->getProtection()->setInsertRows(!$bool);

        // bit: 7; mask 0x0080; insert hyperlinks
        $bool = (0x0080 & $options) >> 7;
        $this->_phpSheet->getProtection()->setInsertHyperlinks(!$bool);

        // bit: 8; mask 0x0100; delete columns
        $bool = (0x0100 & $options) >> 8;
        $this->_phpSheet->getProtection()->setDeleteColumns(!$bool);

        // bit: 9; mask 0x0200; delete rows
        $bool = (0x0200 & $options) >> 9;
        $this->_phpSheet->getProtection()->setDeleteRows(!$bool);

        // bit: 10; mask 0x0400; select locked cells
        $bool = (0x0400 & $options) >> 10;
        $this->_phpSheet->getProtection()->setSelectLockedCells(!$bool);

        // bit: 11; mask 0x0800; sort cell range
        $bool = (0x0800 & $options) >> 11;
        $this->_phpSheet->getProtection()->setSort(!$bool);

        // bit: 12; mask 0x1000; auto filter
        $bool = (0x1000 & $options) >> 12;
        $this->_phpSheet->getProtection()->setAutoFilter(!$bool);

        // bit: 13; mask 0x2000; pivot tables
        $bool = (0x2000 & $options) >> 13;
        $this->_phpSheet->getProtection()->setPivotTables(!$bool);

        // bit: 14; mask 0x4000; select unlocked cells
        $bool = (0x4000 & $options) >> 14;
        $this->_phpSheet->getProtection()->setSelectUnlockedCells(!$bool);

        // offset: 21; size: 2; not used
    }

    /**
     * Read RANGEPROTECTION record
     * Reading of this record is based on Microsoft Office Excel 97-2000 Binary File Format Specification,
     * where it is referred to as FEAT record
     */
    private function _readRangeProtection()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // move stream pointer to next record
        $this->_pos += 4 + $length;

        // local pointer in record data
        $offset = 0;

        if (!$this->_readDataOnly) {
            $offset += 12;

            // offset: 12; size: 2; shared feature type, 2 = enhanced protection, 4 = smart tag
            $isf = self::_GetInt2d($recordData, 12);
            if ($isf != 2) {
                // we only read FEAT records of type 2
                return;
            }
            $offset += 2;

            $offset += 5;

            // offset: 19; size: 2; count of ref ranges this feature is on
            $cref = self::_GetInt2d($recordData, 19);
            $offset += 2;

            $offset += 6;

            // offset: 27; size: 8 * $cref; list of cell ranges (like in hyperlink record)
            $cellRanges = array();
            for ($i = 0; $i < $cref; ++$i) {
                try {
                    $cellRange = $this->_readBIFF8CellRangeAddressFixed(substr($recordData, 27 + 8 * $i, 8));
                } catch (Exception $e) {
                    return;
                }
                $cellRanges[] = $cellRange;
                $offset += 8;
            }

            // offset: var; size: var; variable length of feature specific data
            $rgbFeat = substr($recordData, $offset);
            $offset += 4;

            // offset: var; size: 4; the encrypted password (only 16-bit although field is 32-bit)
            $wPassword = self::_GetInt4d($recordData, $offset);
            $offset += 4;

            // Apply range protection to sheet
            if ($cellRanges) {
                $this->_phpSheet->protectCells(implode(' ', $cellRanges), strtoupper(dechex($wPassword)), true);
            }
        }
    }

    /**
     * Read IMDATA record
     */
    private function _readImData()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);

        // get spliced record data
        $splicedRecordData = $this->_getSplicedRecordData();
        $recordData = $splicedRecordData['recordData'];

        // UNDER CONSTRUCTION

        // offset: 0; size: 2; image format
        $cf = self::_GetInt2d($recordData, 0);

        // offset: 2; size: 2; environment from which the file was written
        $env = self::_GetInt2d($recordData, 2);

        // offset: 4; size: 4; length of the image data
        $lcb = self::_GetInt4d($recordData, 4);

        // offset: 8; size: var; image data
        $iData = substr($recordData, 8);

        switch ($cf) {
        case 0x09: // Windows bitmap format
            // BITMAPCOREINFO
            // 1. BITMAPCOREHEADER
            // offset: 0; size: 4; bcSize, Specifies the number of bytes required by the structure
            $bcSize = self::_GetInt4d($iData, 0);
//            var_dump($bcSize);

            // offset: 4; size: 2; bcWidth, specifies the width of the bitmap, in pixels
            $bcWidth = self::_GetInt2d($iData, 4);
//            var_dump($bcWidth);

            // offset: 6; size: 2; bcHeight, specifies the height of the bitmap, in pixels.
            $bcHeight = self::_GetInt2d($iData, 6);
//            var_dump($bcHeight);
            $ih = imagecreatetruecolor($bcWidth, $bcHeight);

            // offset: 8; size: 2; bcPlanes, specifies the number of planes for the target device. This value must be 1

            // offset: 10; size: 2; bcBitCount specifies the number of bits-per-pixel. This value must be 1, 4, 8, or 24
            $bcBitCount = self::_GetInt2d($iData, 10);
//            var_dump($bcBitCount);

            $rgbString = substr($iData, 12);
            $rgbTriples = array();
            while (strlen($rgbString) > 0) {
                $rgbTriples[] = unpack('Cb/Cg/Cr', $rgbString);
                $rgbString = substr($rgbString, 3);
            }
            $x = 0;
            $y = 0;
            foreach ($rgbTriples as $i => $rgbTriple) {
                $color = imagecolorallocate($ih, $rgbTriple['r'], $rgbTriple['g'], $rgbTriple['b']);
                imagesetpixel($ih, $x, $bcHeight - 1 - $y, $color);
                $x = ($x + 1) % $bcWidth;
                $y = $y + floor(($x + 1) / $bcWidth);
            }
            //imagepng($ih, 'image.png');

            $drawing = new PHPExcel_Worksheet_Drawing();
            $drawing->setPath($filename);
            $drawing->setWorksheet($this->_phpSheet);

            break;

        case 0x02: // Windows metafile or Macintosh PICT format
        case 0x0e: // native format
        default;
            break;

        }

        // _getSplicedRecordData() takes care of moving current position in data stream
    }

    /**
     * Read a free CONTINUE record. Free CONTINUE record may be a camouflaged MSODRAWING record
     * When MSODRAWING data on a sheet exceeds 8224 bytes, CONTINUE records are used instead. Undocumented.
     * In this case, we must treat the CONTINUE record as a MSODRAWING record
     */
    private function _readContinue()
    {
        $length = self::_GetInt2d($this->_data, $this->_pos + 2);
        $recordData = substr($this->_data, $this->_pos + 4, $length);

        // check if we are reading drawing data
        // this is in case a free CONTINUE record occurs in other circumstances we are unaware of
        if ($this->_drawingData == '') {
            // move stream pointer to next record
            $this->_pos += 4 + $length;

            return;
        }

        // check if record data is at least 4 bytes long, otherwise there is no chance this is MSODRAWING data
        if ($length < 4) {
            // move stream pointer to next record
            $this->_pos += 4 + $length;

            return;
        }

        // dirty check to see if CONTINUE record could be a camouflaged MSODRAWING record
        // look inside CONTINUE record to see if it looks like a part of an Escher stream
        // we know that Escher stream may be split at least at
        //        0xF003 MsofbtSpgrContainer
        //        0xF004 MsofbtSpContainer
        //        0xF00D MsofbtClientTextbox
        $validSplitPoints = array(0xF003, 0xF004, 0xF00D); // add identifiers if we find more

        $splitPoint = self::_GetInt2d($recordData, 2);
        if (in_array($splitPoint, $validSplitPoints)) {
            // get spliced record data (and move pointer to next record)
            $splicedRecordData = $this->_getSplicedRecordData();
            $this->_drawingData .= $splicedRecordData['recordData'];

            return;
        }

        // move stream pointer to next record
        $this->_pos += 4 + $length;

    }


    /**
     * Reads a record from current position in data stream and continues reading data as long as CONTINUE
     * records are found. Splices the record data pieces and returns the combined string as if record data
     * is in one piece.
     * Moves to next current position in data stream to start of next record different from a CONtINUE record
     *
     * @return array
     */
    private function _getSplicedRecordData()
    {
        $data = '';
        $spliceOffsets = array();

        $i = 0;
        $spliceOffsets[0] = 0;

        do {
            ++$i;

            // offset: 0; size: 2; identifier
            $identifier = self::_GetInt2d($this->_data, $this->_pos);
            // offset: 2; size: 2; length
            $length = self::_GetInt2d($this->_data, $this->_pos + 2);
            $data .= substr($this->_data, $this->_pos + 4, $length);

            $spliceOffsets[$i] = $spliceOffsets[$i - 1] + $length;

            $this->_pos += 4 + $length;
            $nextIdentifier = self::_GetInt2d($this->_data, $this->_pos);
        }
        while ($nextIdentifier == self::XLS_Type_CONTINUE);

        $splicedData = array(
            'recordData' => $data,
            'spliceOffsets' => $spliceOffsets,
        );

        return $splicedData;

    }

    /**
     * Convert formula structure into human readable Excel formula like 'A3+A5*5'
     *
     * @param string $formulaStructure The complete binary data for the formula
     * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
     * @return string Human readable formula
     */
    private function _getFormulaFromStructure($formulaStructure, $baseCell = 'A1')
    {
        // offset: 0; size: 2; size of the following formula data
        $sz = self::_GetInt2d($formulaStructure, 0);

        // offset: 2; size: sz
        $formulaData = substr($formulaStructure, 2, $sz);

        // for debug: dump the formula data
        //echo '<xmp>';
        //echo 'size: ' . $sz . "\n";
        //echo 'the entire formula data: ';
        //Debug::dump($formulaData);
        //echo "\n----\n";

        // offset: 2 + sz; size: variable (optional)
        if (strlen($formulaStructure) > 2 + $sz) {
            $additionalData = substr($formulaStructure, 2 + $sz);

            // for debug: dump the additional data
            //echo 'the entire additional data: ';
            //Debug::dump($additionalData);
            //echo "\n----\n";

        } else {
            $additionalData = '';
        }

        return $this->_getFormulaFromData($formulaData, $additionalData, $baseCell);
    }

    /**
     * Take formula data and additional data for formula and return human readable formula
     *
     * @param string $formulaData The binary data for the formula itself
     * @param string $additionalData Additional binary data going with the formula
     * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
     * @return string Human readable formula
     */
    private function _getFormulaFromData($formulaData,  $additionalData = '', $baseCell = 'A1')
    {
        // start parsing the formula data
        $tokens = array();

        while (strlen($formulaData) > 0 and $token = $this->_getNextToken($formulaData, $baseCell)) {
            $tokens[] = $token;
            $formulaData = substr($formulaData, $token['size']);

            // for debug: dump the token
            //var_dump($token);
        }

        $formulaString = $this->_createFormulaFromTokens($tokens, $additionalData);

        return $formulaString;
    }

    /**
     * Take array of tokens together with additional data for formula and return human readable formula
     *
     * @param array $tokens
     * @param array $additionalData Additional binary data going with the formula
     * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
     * @return string Human readable formula
     */
    private function _createFormulaFromTokens($tokens, $additionalData)
    {
        // empty formula?
        if (count($tokens) == 0) {
            return '';
        }

        $formulaStrings = array();
        foreach ($tokens as $token) {
            // initialize spaces
            $space0 = isset($space0) ? $space0 : ''; // spaces before next token, not tParen
            $space1 = isset($space1) ? $space1 : ''; // carriage returns before next token, not tParen
            $space2 = isset($space2) ? $space2 : ''; // spaces before opening parenthesis
            $space3 = isset($space3) ? $space3 : ''; // carriage returns before opening parenthesis
            $space4 = isset($space4) ? $space4 : ''; // spaces before closing parenthesis
            $space5 = isset($space5) ? $space5 : ''; // carriage returns before closing parenthesis

            switch ($token['name']) {
            case 'tAdd': // addition
            case 'tConcat': // addition
            case 'tDiv': // division
            case 'tEQ': // equality
            case 'tGE': // greater than or equal
            case 'tGT': // greater than
            case 'tIsect': // intersection
            case 'tLE': // less than or equal
            case 'tList': // less than or equal
            case 'tLT': // less than
            case 'tMul': // multiplication
            case 'tNE': // multiplication
            case 'tPower': // power
            case 'tRange': // range
            case 'tSub': // subtraction
                $op2 = array_pop($formulaStrings);
                $op1 = array_pop($formulaStrings);
                $formulaStrings[] = "$op1$space1$space0{$token['data']}$op2";
                unset($space0, $space1);
                break;
            case 'tUplus': // unary plus
            case 'tUminus': // unary minus
                $op = array_pop($formulaStrings);
                $formulaStrings[] = "$space1$space0{$token['data']}$op";
                unset($space0, $space1);
                break;
            case 'tPercent': // percent sign
                $op = array_pop($formulaStrings);
                $formulaStrings[] = "$op$space1$space0{$token['data']}";
                unset($space0, $space1);
                break;
            case 'tAttrVolatile': // indicates volatile function
            case 'tAttrIf':
            case 'tAttrSkip':
            case 'tAttrChoose':
                // token is only important for Excel formula evaluator
                // do nothing
                break;
            case 'tAttrSpace': // space / carriage return
                // space will be used when next token arrives, do not alter formulaString stack
                switch ($token['data']['spacetype']) {
                case 'type0':
                    $space0 = str_repeat(' ', $token['data']['spacecount']);
                    break;
                case 'type1':
                    $space1 = str_repeat("\n", $token['data']['spacecount']);
                    break;
                case 'type2':
                    $space2 = str_repeat(' ', $token['data']['spacecount']);
                    break;
                case 'type3':
                    $space3 = str_repeat("\n", $token['data']['spacecount']);
                    break;
                case 'type4':
                    $space4 = str_repeat(' ', $token['data']['spacecount']);
                    break;
                case 'type5':
                    $space5 = str_repeat("\n", $token['data']['spacecount']);
                    break;
                }
                break;
            case 'tAttrSum': // SUM function with one parameter
                $op = array_pop($formulaStrings);
                $formulaStrings[] = "{$space1}{$space0}SUM($op)";
                unset($space0, $space1);
                break;
            case 'tFunc': // function with fixed number of arguments
            case 'tFuncV': // function with variable number of arguments
                if ($token['data']['function'] != '') {
                    // normal function
                    $ops = array(); // array of operators
                    for ($i = 0; $i < $token['data']['args']; ++$i) {
                        $ops[] = array_pop($formulaStrings);
                    }
                    $ops = array_reverse($ops);
                    $formulaStrings[] = "$space1$space0{$token['data']['function']}(" . implode(',', $ops) . ")";
                    unset($space0, $space1);
                } else {
                    // add-in function
                    $ops = array(); // array of operators
                    for ($i = 0; $i < $token['data']['args'] - 1; ++$i) {
                        $ops[] = array_pop($formulaStrings);
                    }
                    $ops = array_reverse($ops);
                    $function = array_pop($formulaStrings);
                    $formulaStrings[] = "$space1$space0$function(" . implode(',', $ops) . ")";
                    unset($space0, $space1);
                }
                break;
            case 'tParen': // parenthesis
                $expression = array_pop($formulaStrings);
                $formulaStrings[] = "$space3$space2($expression$space5$space4)";
                unset($space2, $space3, $space4, $space5);
                break;
            case 'tArray': // array constant
                $constantArray = self::_readBIFF8ConstantArray($additionalData);
                $formulaStrings[] = $space1 . $space0 . $constantArray['value'];
                $additionalData = substr($additionalData, $constantArray['size']); // bite of chunk of additional data
                unset($space0, $space1);
                break;
            case 'tMemArea':
                // bite off chunk of additional data
                $cellRangeAddressList = $this->_readBIFF8CellRangeAddressList($additionalData);
                $additionalData = substr($additionalData, $cellRangeAddressList['size']);
                $formulaStrings[] = "$space1$space0{$token['data']}";
                unset($space0, $space1);
                break;
            case 'tArea': // cell range address
            case 'tBool': // boolean
            case 'tErr': // error code
            case 'tInt': // integer
            case 'tMemErr':
            case 'tMemFunc':
            case 'tMissArg':
            case 'tName':
            case 'tNameX':
            case 'tNum': // number
            case 'tRef': // single cell reference
            case 'tRef3d': // 3d cell reference
            case 'tArea3d': // 3d cell range reference
            case 'tRefN':
            case 'tAreaN':
            case 'tStr': // string
                $formulaStrings[] = "$space1$space0{$token['data']}";
                unset($space0, $space1);
                break;
            }
        }
        $formulaString = $formulaStrings[0];

        // for debug: dump the human readable formula
        //echo '----' . "\n";
        //echo 'Formula: ' . $formulaString;

        return $formulaString;
    }

    /**
     * Fetch next token from binary formula data
     *
     * @param string Formula data
     * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
     * @return array
     * @throws Exception
     */
    private function _getNextToken($formulaData, $baseCell = 'A1')
    {
        // offset: 0; size: 1; token id
        $id = ord($formulaData[0]); // token id
        $name = false; // initialize token name

        switch ($id) {
        case 0x03: $name = 'tAdd';        $size = 1;    $data = '+';    break;
        case 0x04: $name = 'tSub';        $size = 1;    $data = '-';    break;
        case 0x05: $name = 'tMul';        $size = 1;    $data = '*';    break;
        case 0x06: $name = 'tDiv';        $size = 1;    $data = '/';    break;
        case 0x07: $name = 'tPower';    $size = 1;    $data = '^';    break;
        case 0x08: $name = 'tConcat';    $size = 1;    $data = '&';    break;
        case 0x09: $name = 'tLT';        $size = 1;    $data = '<';    break;
        case 0x0A: $name = 'tLE';        $size = 1;    $data = '<=';    break;
        case 0x0B: $name = 'tEQ';        $size = 1;    $data = '=';    break;
        case 0x0C: $name = 'tGE';        $size = 1;    $data = '>=';    break;
        case 0x0D: $name = 'tGT';        $size = 1;    $data = '>';    break;
        case 0x0E: $name = 'tNE';        $size = 1;    $data = '<>';    break;
        case 0x0F: $name = 'tIsect';    $size = 1;    $data = ' ';    break;
        case 0x10: $name = 'tList';        $size = 1;    $data = ',';    break;
        case 0x11: $name = 'tRange';    $size = 1;    $data = ':';    break;
        case 0x12: $name = 'tUplus';    $size = 1;    $data = '+';    break;
        case 0x13: $name = 'tUminus';    $size = 1;    $data = '-';    break;
        case 0x14: $name = 'tPercent';    $size = 1;    $data = '%';    break;
        case 0x15:    //    parenthesis
            $name  = 'tParen';
            $size  = 1;
            $data = null;
            break;
        case 0x16:    //    missing argument
            $name = 'tMissArg';
            $size = 1;
            $data = '';
            break;
        case 0x17:    //    string
            $name = 'tStr';
            // offset: 1; size: var; Unicode string, 8-bit string length
            $string = self::_readUnicodeStringShort(substr($formulaData, 1));
            $size = 1 + $string['size'];
            $data = self::_UTF8toExcelDoubleQuoted($string['value']);
            break;
        case 0x19:    //    Special attribute
            // offset: 1; size: 1; attribute type flags:
            switch (ord($formulaData[1])) {
            case 0x01:
                $name = 'tAttrVolatile';
                $size = 4;
                $data = null;
                break;
            case 0x02:
                $name = 'tAttrIf';
                $size = 4;
                $data = null;
                break;
            case 0x04:
                $name = 'tAttrChoose';
                // offset: 2; size: 2; number of choices in the CHOOSE function ($nc, number of parameters decreased by 1)
                $nc = self::_GetInt2d($formulaData, 2);
                // offset: 4; size: 2 * $nc
                // offset: 4 + 2 * $nc; size: 2
                $size = 2 * $nc + 6;
                $data = null;
                break;
            case 0x08:
                $name = 'tAttrSkip';
                $size = 4;
                $data = null;
                break;
            case 0x10:
                $name = 'tAttrSum';
                $size = 4;
                $data = null;
                break;
            case 0x40:
            case 0x41:
                $name = 'tAttrSpace';
                $size = 4;
                // offset: 2; size: 2; space type and position
                switch (ord($formulaData[2])) {
                case 0x00:
                    $spacetype = 'type0';
                    break;
                case 0x01:
                    $spacetype = 'type1';
                    break;
                case 0x02:
                    $spacetype = 'type2';
                    break;
                case 0x03:
                    $spacetype = 'type3';
                    break;
                case 0x04:
                    $spacetype = 'type4';
                    break;
                case 0x05:
                    $spacetype = 'type5';
                    break;
                default:
                    throw new Exception('Unrecognized space type in tAttrSpace token');
                    break;
                }
                // offset: 3; size: 1; number of inserted spaces/carriage returns
                $spacecount = ord($formulaData[3]);

                $data = array('spacetype' => $spacetype, 'spacecount' => $spacecount);
                break;
            default:
                throw new Exception('Unrecognized attribute flag in tAttr token');
                break;
            }
            break;
        case 0x1C:    //    error code
            // offset: 1; size: 1; error code
            $name = 'tErr';
            $size = 2;
            $data = self::_mapErrorCode(ord($formulaData[1]));
            break;
        case 0x1D:    //    boolean
            // offset: 1; size: 1; 0 = false, 1 = true;
            $name = 'tBool';
            $size = 2;
            $data = ord($formulaData[1]) ? 'TRUE' : 'FALSE';
            break;
        case 0x1E:    //    integer
            // offset: 1; size: 2; unsigned 16-bit integer
            $name = 'tInt';
            $size = 3;
            $data = self::_GetInt2d($formulaData, 1);
            break;
        case 0x1F:    //    number
            // offset: 1; size: 8;
            $name = 'tNum';
            $size = 9;
            $data = self::_extractNumber(substr($formulaData, 1));
            $data = str_replace(',', '.', (string)$data); // in case non-English locale
            break;
        case 0x20:    //    array constant
        case 0x40:
        case 0x60:
            // offset: 1; size: 7; not used
            $name = 'tArray';
            $size = 8;
            $data = null;
            break;
        case 0x21:    //    function with fixed number of arguments
        case 0x41:
        case 0x61:
            $name = 'tFunc';
            $size = 3;
            // offset: 1; size: 2; index to built-in sheet function
            switch (self::_GetInt2d($formulaData, 1)) {
            case   2: $function = 'ISNA';             $args = 1;     break;
            case   3: $function = 'ISERROR';         $args = 1;     break;
            case  10: $function = 'NA';             $args = 0;     break;
            case  15: $function = 'SIN';             $args = 1;     break;
            case  16: $function = 'COS';             $args = 1;     break;
            case  17: $function = 'TAN';             $args = 1;     break;
            case  18: $function = 'ATAN';             $args = 1;     break;
            case  19: $function = 'PI';             $args = 0;     break;
            case  20: $function = 'SQRT';             $args = 1;     break;
            case  21: $function = 'EXP';             $args = 1;     break;
            case  22: $function = 'LN';             $args = 1;     break;
            case  23: $function = 'LOG10';             $args = 1;     break;
            case  24: $function = 'ABS';             $args = 1;     break;
            case  25: $function = 'INT';             $args = 1;     break;
            case  26: $function = 'SIGN';             $args = 1;     break;
            case  27: $function = 'ROUND';             $args = 2;     break;
            case  30: $function = 'REPT';             $args = 2;     break;
            case  31: $function = 'MID';             $args = 3;     break;
            case  32: $function = 'LEN';             $args = 1;     break;
            case  33: $function = 'VALUE';             $args = 1;     break;
            case  34: $function = 'TRUE';             $args = 0;     break;
            case  35: $function = 'FALSE';             $args = 0;     break;
            case  38: $function = 'NOT';             $args = 1;     break;
            case  39: $function = 'MOD';             $args = 2;    break;
            case  40: $function = 'DCOUNT';         $args = 3;    break;
            case  41: $function = 'DSUM';             $args = 3;    break;
            case  42: $function = 'DAVERAGE';         $args = 3;    break;
            case  43: $function = 'DMIN';             $args = 3;    break;
            case  44: $function = 'DMAX';             $args = 3;    break;
            case  45: $function = 'DSTDEV';         $args = 3;    break;
            case  48: $function = 'TEXT';             $args = 2;    break;
            case  61: $function = 'MIRR';             $args = 3;    break;
            case  63: $function = 'RAND';             $args = 0;    break;
            case  65: $function = 'DATE';             $args = 3;    break;
            case  66: $function = 'TIME';             $args = 3;    break;
            case  67: $function = 'DAY';             $args = 1;    break;
            case  68: $function = 'MONTH';             $args = 1;    break;
            case  69: $function = 'YEAR';             $args = 1;    break;
            case  71: $function = 'HOUR';             $args = 1;    break;
            case  72: $function = 'MINUTE';         $args = 1;    break;
            case  73: $function = 'SECOND';         $args = 1;    break;
            case  74: $function = 'NOW';             $args = 0;    break;
            case  75: $function = 'AREAS';             $args = 1;    break;
            case  76: $function = 'ROWS';             $args = 1;    break;
            case  77: $function = 'COLUMNS';         $args = 1;    break;
            case  83: $function = 'TRANSPOSE';         $args = 1;    break;
            case  86: $function = 'TYPE';             $args = 1;    break;
            case  97: $function = 'ATAN2';             $args = 2;    break;
            case  98: $function = 'ASIN';             $args = 1;    break;
            case  99: $function = 'ACOS';             $args = 1;    break;
            case 105: $function = 'ISREF';             $args = 1;    break;
            case 111: $function = 'CHAR';             $args = 1;    break;
            case 112: $function = 'LOWER';             $args = 1;    break;
            case 113: $function = 'UPPER';             $args = 1;    break;
            case 114: $function = 'PROPER';         $args = 1;    break;
            case 117: $function = 'EXACT';             $args = 2;    break;
            case 118: $function = 'TRIM';             $args = 1;    break;
            case 119: $function = 'REPLACE';         $args = 4;    break;
            case 121: $function = 'CODE';             $args = 1;    break;
            case 126: $function = 'ISERR';             $args = 1;    break;
            case 127: $function = 'ISTEXT';         $args = 1;    break;
            case 128: $function = 'ISNUMBER';         $args = 1;    break;
            case 129: $function = 'ISBLANK';         $args = 1;    break;
            case 130: $function = 'T';                 $args = 1;    break;
            case 131: $function = 'N';                 $args = 1;    break;
            case 140: $function = 'DATEVALUE';         $args = 1;    break;
            case 141: $function = 'TIMEVALUE';         $args = 1;    break;
            case 142: $function = 'SLN';             $args = 3;    break;
            case 143: $function = 'SYD';             $args = 4;    break;
            case 162: $function = 'CLEAN';             $args = 1;    break;
            case 163: $function = 'MDETERM';         $args = 1;    break;
            case 164: $function = 'MINVERSE';         $args = 1;    break;
            case 165: $function = 'MMULT';             $args = 2;    break;
            case 184: $function = 'FACT';             $args = 1;    break;
            case 189: $function = 'DPRODUCT';         $args = 3;    break;
            case 190: $function = 'ISNONTEXT';         $args = 1;    break;
            case 195: $function = 'DSTDEVP';         $args = 3;    break;
            case 196: $function = 'DVARP';             $args = 3;    break;
            case 198: $function = 'ISLOGICAL';         $args = 1;    break;
            case 199: $function = 'DCOUNTA';         $args = 3;    break;
            case 207: $function = 'REPLACEB';         $args = 4;    break;
            case 210: $function = 'MIDB';             $args = 3;    break;
            case 211: $function = 'LENB';             $args = 1;    break;
            case 212: $function = 'ROUNDUP';         $args = 2;    break;
            case 213: $function = 'ROUNDDOWN';         $args = 2;    break;
            case 214: $function = 'ASC';             $args = 1;    break;
            case 215: $function = 'DBCS';             $args = 1;    break;
            case 221: $function = 'TODAY';             $args = 0;    break;
            case 229: $function = 'SINH';             $args = 1;    break;
            case 230: $function = 'COSH';             $args = 1;    break;
            case 231: $function = 'TANH';             $args = 1;    break;
            case 232: $function = 'ASINH';             $args = 1;    break;
            case 233: $function = 'ACOSH';             $args = 1;    break;
            case 234: $function = 'ATANH';             $args = 1;    break;
            case 235: $function = 'DGET';             $args = 3;    break;
            case 244: $function = 'INFO';             $args = 1;    break;
            case 252: $function = 'FREQUENCY';         $args = 2;    break;
            case 261: $function = 'ERROR.TYPE';     $args = 1;    break;
            case 271: $function = 'GAMMALN';         $args = 1;    break;
            case 273: $function = 'BINOMDIST';         $args = 4;    break;
            case 274: $function = 'CHIDIST';         $args = 2;    break;
            case 275: $function = 'CHIINV';         $args = 2;    break;
            case 276: $function = 'COMBIN';         $args = 2;    break;
            case 277: $function = 'CONFIDENCE';     $args = 3;    break;
            case 278: $function = 'CRITBINOM';         $args = 3;    break;
            case 279: $function = 'EVEN';             $args = 1;    break;
            case 280: $function = 'EXPONDIST';         $args = 3;    break;
            case 281: $function = 'FDIST';             $args = 3;    break;
            case 282: $function = 'FINV';             $args = 3;    break;
            case 283: $function = 'FISHER';         $args = 1;    break;
            case 284: $function = 'FISHERINV';         $args = 1;    break;
            case 285: $function = 'FLOOR';             $args = 2;    break;
            case 286: $function = 'GAMMADIST';         $args = 4;    break;
            case 287: $function = 'GAMMAINV';         $args = 3;    break;
            case 288: $function = 'CEILING';         $args = 2;    break;
            case 289: $function = 'HYPGEOMDIST';    $args = 4;    break;
            case 290: $function = 'LOGNORMDIST';    $args = 3;    break;
            case 291: $function = 'LOGINV';            $args = 3;    break;
            case 292: $function = 'NEGBINOMDIST';    $args = 3;    break;
            case 293: $function = 'NORMDIST';        $args = 4;    break;
            case 294: $function = 'NORMSDIST';        $args = 1;    break;
            case 295: $function = 'NORMINV';        $args = 3;    break;
            case 296: $function = 'NORMSINV';        $args = 1;    break;
            case 297: $function = 'STANDARDIZE';    $args = 3;    break;
            case 298: $function = 'ODD';            $args = 1;    break;
            case 299: $function = 'PERMUT';            $args = 2;    break;
            case 300: $function = 'POISSON';        $args = 3;    break;
            case 301: $function = 'TDIST';            $args = 3;    break;
            case 302: $function = 'WEIBULL';        $args = 4;    break;
            case 303: $function = 'SUMXMY2';        $args = 2;    break;
            case 304: $function = 'SUMX2MY2';        $args = 2;    break;
            case 305: $function = 'SUMX2PY2';        $args = 2;    break;
            case 306: $function = 'CHITEST';        $args = 2;    break;
            case 307: $function = 'CORREL';            $args = 2;    break;
            case 308: $function = 'COVAR';            $args = 2;    break;
            case 309: $function = 'FORECAST';        $args = 3;    break;
            case 310: $function = 'FTEST';            $args = 2;    break;
            case 311: $function = 'INTERCEPT';        $args = 2;    break;
            case 312: $function = 'PEARSON';        $args = 2;    break;
            case 313: $function = 'RSQ';            $args = 2;    break;
            case 314: $function = 'STEYX';            $args = 2;    break;
            case 315: $function = 'SLOPE';            $args = 2;    break;
            case 316: $function = 'TTEST';            $args = 4;    break;
            case 325: $function = 'LARGE';            $args = 2;    break;
            case 326: $function = 'SMALL';            $args = 2;    break;
            case 327: $function = 'QUARTILE';        $args = 2;    break;
            case 328: $function = 'PERCENTILE';        $args = 2;    break;
            case 331: $function = 'TRIMMEAN';        $args = 2;    break;
            case 332: $function = 'TINV';            $args = 2;    break;
            case 337: $function = 'POWER';            $args = 2;    break;
            case 342: $function = 'RADIANS';        $args = 1;    break;
            case 343: $function = 'DEGREES';        $args = 1;    break;
            case 346: $function = 'COUNTIF';        $args = 2;    break;
            case 347: $function = 'COUNTBLANK';        $args = 1;    break;
            case 350: $function = 'ISPMT';            $args = 4;    break;
            case 351: $function = 'DATEDIF';        $args = 3;    break;
            case 352: $function = 'DATESTRING';        $args = 1;    break;
            case 353: $function = 'NUMBERSTRING';    $args = 2;    break;
            case 360: $function = 'PHONETIC';        $args = 1;    break;
            case 368: $function = 'BAHTTEXT';        $args = 1;    break;
            default:
                throw new Exception('Unrecognized function in formula');
                break;
            }
            $data = array('function' => $function, 'args' => $args);
            break;
        case 0x22:    //    function with variable number of arguments
        case 0x42:
        case 0x62:
            $name = 'tFuncV';
            $size = 4;
            // offset: 1; size: 1; number of arguments
            $args = ord($formulaData[1]);
            // offset: 2: size: 2; index to built-in sheet function
            $index = self::_GetInt2d($formulaData, 2);
            switch ($index) {
            case   0: $function = 'COUNT';            break;
            case   1: $function = 'IF';                break;
            case   4: $function = 'SUM';            break;
            case   5: $function = 'AVERAGE';        break;
            case   6: $function = 'MIN';            break;
            case   7: $function = 'MAX';            break;
            case   8: $function = 'ROW';            break;
            case   9: $function = 'COLUMN';            break;
            case  11: $function = 'NPV';            break;
            case  12: $function = 'STDEV';            break;
            case  13: $function = 'DOLLAR';            break;
            case  14: $function = 'FIXED';            break;
            case  28: $function = 'LOOKUP';            break;
            case  29: $function = 'INDEX';            break;
            case  36: $function = 'AND';            break;
            case  37: $function = 'OR';                break;
            case  46: $function = 'VAR';            break;
            case  49: $function = 'LINEST';            break;
            case  50: $function = 'TREND';            break;
            case  51: $function = 'LOGEST';            break;
            case  52: $function = 'GROWTH';            break;
            case  56: $function = 'PV';                break;
            case  57: $function = 'FV';                break;
            case  58: $function = 'NPER';            break;
            case  59: $function = 'PMT';            break;
            case  60: $function = 'RATE';            break;
            case  62: $function = 'IRR';            break;
            case  64: $function = 'MATCH';            break;
            case  70: $function = 'WEEKDAY';        break;
            case  78: $function = 'OFFSET';            break;
            case  82: $function = 'SEARCH';            break;
            case 100: $function = 'CHOOSE';            break;
            case 101: $function = 'HLOOKUP';        break;
            case 102: $function = 'VLOOKUP';        break;
            case 109: $function = 'LOG';            break;
            case 115: $function = 'LEFT';            break;
            case 116: $function = 'RIGHT';            break;
            case 120: $function = 'SUBSTITUTE';        break;
            case 124: $function = 'FIND';            break;
            case 125: $function = 'CELL';            break;
            case 144: $function = 'DDB';            break;
            case 148: $function = 'INDIRECT';        break;
            case 167: $function = 'IPMT';            break;
            case 168: $function = 'PPMT';            break;
            case 169: $function = 'COUNTA';            break;
            case 183: $function = 'PRODUCT';        break;
            case 193: $function = 'STDEVP';            break;
            case 194: $function = 'VARP';            break;
            case 197: $function = 'TRUNC';            break;
            case 204: $function = 'USDOLLAR';        break;
            case 205: $function = 'FINDB';            break;
            case 206: $function = 'SEARCHB';        break;
            case 208: $function = 'LEFTB';            break;
            case 209: $function = 'RIGHTB';            break;
            case 216: $function = 'RANK';            break;
            case 219: $function = 'ADDRESS';        break;
            case 220: $function = 'DAYS360';        break;
            case 222: $function = 'VDB';            break;
            case 227: $function = 'MEDIAN';            break;
            case 228: $function = 'SUMPRODUCT';        break;
            case 247: $function = 'DB';                break;
            case 255: $function = '';                break;
            case 269: $function = 'AVEDEV';            break;
            case 270: $function = 'BETADIST';        break;
            case 272: $function = 'BETAINV';        break;
            case 317: $function = 'PROB';            break;
            case 318: $function = 'DEVSQ';            break;
            case 319: $function = 'GEOMEAN';        break;
            case 320: $function = 'HARMEAN';        break;
            case 321: $function = 'SUMSQ';            break;
            case 322: $function = 'KURT';            break;
            case 323: $function = 'SKEW';            break;
            case 324: $function = 'ZTEST';            break;
            case 329: $function = 'PERCENTRANK';    break;
            case 330: $function = 'MODE';            break;
            case 336: $function = 'CONCATENATE';    break;
            case 344: $function = 'SUBTOTAL';        break;
            case 345: $function = 'SUMIF';            break;
            case 354: $function = 'ROMAN';            break;
            case 358: $function = 'GETPIVOTDATA';    break;
            case 359: $function = 'HYPERLINK';        break;
            case 361: $function = 'AVERAGEA';        break;
            case 362: $function = 'MAXA';            break;
            case 363: $function = 'MINA';            break;
            case 364: $function = 'STDEVPA';        break;
            case 365: $function = 'VARPA';            break;
            case 366: $function = 'STDEVA';            break;
            case 367: $function = 'VARA';            break;
            default:
                throw new Exception('Unrecognized function in formula');
                break;
            }
            $data = array('function' => $function, 'args' => $args);
            break;
        case 0x23:    //    index to defined name
        case 0x43:
        case 0x63:
            $name = 'tName';
            $size = 5;
            // offset: 1; size: 2; one-based index to definedname record
            $definedNameIndex = self::_GetInt2d($formulaData, 1) - 1;
            // offset: 2; size: 2; not used
            $data = $this->_definedname[$definedNameIndex]['name'];
            break;
        case 0x24:    //    single cell reference e.g. A5
        case 0x44:
        case 0x64:
            $name = 'tRef';
            $size = 5;
            $data = $this->_readBIFF8CellAddress(substr($formulaData, 1, 4));
            break;
        case 0x25:    //    cell range reference to cells in the same sheet (2d)
        case 0x45:
        case 0x65:
            $name = 'tArea';
            $size = 9;
            $data = $this->_readBIFF8CellRangeAddress(substr($formulaData, 1, 8));
            break;
        case 0x26:    //    Constant reference sub-expression
        case 0x46:
        case 0x66:
            $name = 'tMemArea';
            // offset: 1; size: 4; not used
            // offset: 5; size: 2; size of the following subexpression
            $subSize = self::_GetInt2d($formulaData, 5);
            $size = 7 + $subSize;
            $data = $this->_getFormulaFromData(substr($formulaData, 7, $subSize));
            break;
        case 0x27:    //    Deleted constant reference sub-expression
        case 0x47:
        case 0x67:
            $name = 'tMemErr';
            // offset: 1; size: 4; not used
            // offset: 5; size: 2; size of the following subexpression
            $subSize = self::_GetInt2d($formulaData, 5);
            $size = 7 + $subSize;
            $data = $this->_getFormulaFromData(substr($formulaData, 7, $subSize));
            break;
        case 0x29:    //    Variable reference sub-expression
        case 0x49:
        case 0x69:
            $name = 'tMemFunc';
            // offset: 1; size: 2; size of the following sub-expression
            $subSize = self::_GetInt2d($formulaData, 1);
            $size = 3 + $subSize;
            $data = $this->_getFormulaFromData(substr($formulaData, 3, $subSize));
            break;

        case 0x2C: // Relative 2d cell reference reference, used in shared formulas and some other places
        case 0x4C:
        case 0x6C:
            $name = 'tRefN';
            $size = 5;
            $data = $this->_readBIFF8CellAddressB(substr($formulaData, 1, 4), $baseCell);
            break;

        case 0x2D:    //    Relative 2d range reference
        case 0x4D:
        case 0x6D:
            $name = 'tAreaN';
            $size = 9;
            $data = $this->_readBIFF8CellRangeAddressB(substr($formulaData, 1, 8), $baseCell);
            break;

        case 0x39:    //    External name
        case 0x59:
        case 0x79:
            $name = 'tNameX';
            $size = 7;
            // offset: 1; size: 2; index to REF entry in EXTERNSHEET record
            // offset: 3; size: 2; one-based index to DEFINEDNAME or EXTERNNAME record
            $index = self::_GetInt2d($formulaData, 3);
            // assume index is to EXTERNNAME record
            $data = $this->_externalNames[$index - 1]['name'];
            // offset: 5; size: 2; not used
            break;

        case 0x3A:    //    3d reference to cell
        case 0x5A:
        case 0x7A:
            $name = 'tRef3d';
            $size = 7;

            try {
                // offset: 1; size: 2; index to REF entry
                $sheetRange = $this->_readSheetRangeByRefIndex(self::_GetInt2d($formulaData, 1));
                // offset: 3; size: 4; cell address
                $cellAddress = $this->_readBIFF8CellAddress(substr($formulaData, 3, 4));

                $data = "$sheetRange!$cellAddress";
            } catch (Exception $e) {
                // deleted sheet reference
                $data = '#REF!';
            }

            break;
        case 0x3B:    //    3d reference to cell range
        case 0x5B:
        case 0x7B:
            $name = 'tArea3d';
            $size = 11;

            try {
                // offset: 1; size: 2; index to REF entry
                $sheetRange = $this->_readSheetRangeByRefIndex(self::_GetInt2d($formulaData, 1));
                // offset: 3; size: 8; cell address
                $cellRangeAddress = $this->_readBIFF8CellRangeAddress(substr($formulaData, 3, 8));

                $data = "$sheetRange!$cellRangeAddress";
            } catch (Exception $e) {
                // deleted sheet reference
                $data = '#REF!';
            }

            break;
        // Unknown cases    // don't know how to deal with
        default:
            throw new Exception('Unrecognized token ' . sprintf('%02X', $id) . ' in formula');
            break;
        }

        return array(
            'id' => $id,
            'name' => $name,
            'size' => $size,
            'data' => $data,
        );
    }

    /**
     * Reads a cell address in BIFF8 e.g. 'A2' or '$A$2'
     * section 3.3.4
     *
     * @param string $cellAddressStructure
     * @return string
     */
    private function _readBIFF8CellAddress($cellAddressStructure)
    {
        // offset: 0; size: 2; index to row (0... 65535) (or offset (-32768... 32767))
        $row = self::_GetInt2d($cellAddressStructure, 0) + 1;

        // offset: 2; size: 2; index to column or column offset + relative flags

            // bit: 7-0; mask 0x00FF; column index
            $column = PHPExcel_Cell::stringFromColumnIndex(0x00FF & self::_GetInt2d($cellAddressStructure, 2));

            // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
            if (!(0x4000 & self::_GetInt2d($cellAddressStructure, 2))) {
                $column = '$' . $column;
            }
            // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
            if (!(0x8000 & self::_GetInt2d($cellAddressStructure, 2))) {
                $row = '$' . $row;
            }

        return $column . $row;
    }

    /**
     * Reads a cell address in BIFF8 for shared formulas. Uses positive and negative values for row and column
     * to indicate offsets from a base cell
     * section 3.3.4
     *
     * @param string $cellAddressStructure
     * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
     * @return string
     */
    private function _readBIFF8CellAddressB($cellAddressStructure, $baseCell = 'A1')
    {
        list($baseCol, $baseRow) = PHPExcel_Cell::coordinateFromString($baseCell);
        $baseCol = PHPExcel_Cell::columnIndexFromString($baseCol) - 1;

        // offset: 0; size: 2; index to row (0... 65535) (or offset (-32768... 32767))
            $rowIndex = self::_GetInt2d($cellAddressStructure, 0);
            $row = self::_GetInt2d($cellAddressStructure, 0) + 1;

        // offset: 2; size: 2; index to column or column offset + relative flags

            // bit: 7-0; mask 0x00FF; column index
            $colIndex = 0x00FF & self::_GetInt2d($cellAddressStructure, 2);

            // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
            if (!(0x4000 & self::_GetInt2d($cellAddressStructure, 2))) {
                $column = PHPExcel_Cell::stringFromColumnIndex($colIndex);
                $column = '$' . $column;
            } else {
                $colIndex = ($colIndex <= 127) ? $colIndex : $colIndex - 256;
                $column = PHPExcel_Cell::stringFromColumnIndex($baseCol + $colIndex);
            }

            // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
            if (!(0x8000 & self::_GetInt2d($cellAddressStructure, 2))) {
                $row = '$' . $row;
            } else {
                $rowIndex = ($rowIndex <= 32767) ? $rowIndex : $rowIndex - 65536;
                $row = $baseRow + $rowIndex;
            }

        return $column . $row;
    }

    /**
     * Reads a cell range address in BIFF5 e.g. 'A2:B6' or 'A1'
     * always fixed range
     * section 2.5.14
     *
     * @param string $subData
     * @return string
     * @throws Exception
     */
    private function _readBIFF5CellRangeAddressFixed($subData)
    {
        // offset: 0; size: 2; index to first row
        $fr = self::_GetInt2d($subData, 0) + 1;

        // offset: 2; size: 2; index to last row
        $lr = self::_GetInt2d($subData, 2) + 1;

        // offset: 4; size: 1; index to first column
        $fc = ord($subData{4});

        // offset: 5; size: 1; index to last column
        $lc = ord($subData{5});

        // check values
        if ($fr > $lr || $fc > $lc) {
            throw new Exception('Not a cell range address');
        }

        // column index to letter
        $fc = PHPExcel_Cell::stringFromColumnIndex($fc);
        $lc = PHPExcel_Cell::stringFromColumnIndex($lc);

        if ($fr == $lr and $fc == $lc) {
            return "$fc$fr";
        }
        return "$fc$fr:$lc$lr";
    }

    /**
     * Reads a cell range address in BIFF8 e.g. 'A2:B6' or 'A1'
     * always fixed range
     * section 2.5.14
     *
     * @param string $subData
     * @return string
     * @throws Exception
     */
    private function _readBIFF8CellRangeAddressFixed($subData)
    {
        // offset: 0; size: 2; index to first row
        $fr = self::_GetInt2d($subData, 0) + 1;

        // offset: 2; size: 2; index to last row
        $lr = self::_GetInt2d($subData, 2) + 1;

        // offset: 4; size: 2; index to first column
        $fc = self::_GetInt2d($subData, 4);

        // offset: 6; size: 2; index to last column
        $lc = self::_GetInt2d($subData, 6);

        // check values
        if ($fr > $lr || $fc > $lc) {
            throw new Exception('Not a cell range address');
        }

        // column index to letter
        $fc = PHPExcel_Cell::stringFromColumnIndex($fc);
        $lc = PHPExcel_Cell::stringFromColumnIndex($lc);

        if ($fr == $lr and $fc == $lc) {
            return "$fc$fr";
        }
        return "$fc$fr:$lc$lr";
    }

    /**
     * Reads a cell range address in BIFF8 e.g. 'A2:B6' or '$A$2:$B$6'
     * there are flags indicating whether column/row index is relative
     * section 3.3.4
     *
     * @param string $subData
     * @return string
     */
    private function _readBIFF8CellRangeAddress($subData)
    {
        // todo: if cell range is just a single cell, should this funciton
        // not just return e.g. 'A1' and not 'A1:A1' ?

        // offset: 0; size: 2; index to first row (0... 65535) (or offset (-32768... 32767))
            $fr = self::_GetInt2d($subData, 0) + 1;

        // offset: 2; size: 2; index to last row (0... 65535) (or offset (-32768... 32767))
            $lr = self::_GetInt2d($subData, 2) + 1;

        // offset: 4; size: 2; index to first column or column offset + relative flags

            // bit: 7-0; mask 0x00FF; column index
            $fc = PHPExcel_Cell::stringFromColumnIndex(0x00FF & self::_GetInt2d($subData, 4));

            // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
            if (!(0x4000 & self::_GetInt2d($subData, 4))) {
                $fc = '$' . $fc;
            }

            // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
            if (!(0x8000 & self::_GetInt2d($subData, 4))) {
                $fr = '$' . $fr;
            }

        // offset: 6; size: 2; index to last column or column offset + relative flags

            // bit: 7-0; mask 0x00FF; column index
            $lc = PHPExcel_Cell::stringFromColumnIndex(0x00FF & self::_GetInt2d($subData, 6));

            // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
            if (!(0x4000 & self::_GetInt2d($subData, 6))) {
                $lc = '$' . $lc;
            }

            // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
            if (!(0x8000 & self::_GetInt2d($subData, 6))) {
                $lr = '$' . $lr;
            }

        return "$fc$fr:$lc$lr";
    }

    /**
     * Reads a cell range address in BIFF8 for shared formulas. Uses positive and negative values for row and column
     * to indicate offsets from a base cell
     * section 3.3.4
     *
     * @param string $subData
     * @param string $baseCell Base cell
     * @return string Cell range address
     */
    private function _readBIFF8CellRangeAddressB($subData, $baseCell = 'A1')
    {
        list($baseCol, $baseRow) = PHPExcel_Cell::coordinateFromString($baseCell);
        $baseCol = PHPExcel_Cell::columnIndexFromString($baseCol) - 1;

        // TODO: if cell range is just a single cell, should this funciton
        // not just return e.g. 'A1' and not 'A1:A1' ?

        // offset: 0; size: 2; first row
        $frIndex = self::_GetInt2d($subData, 0); // adjust below

        // offset: 2; size: 2; relative index to first row (0... 65535) should be treated as offset (-32768... 32767)
        $lrIndex = self::_GetInt2d($subData, 2); // adjust below

        // offset: 4; size: 2; first column with relative/absolute flags

            // bit: 7-0; mask 0x00FF; column index
            $fcIndex = 0x00FF & self::_GetInt2d($subData, 4);

            // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
            if (!(0x4000 & self::_GetInt2d($subData, 4))) {
                // absolute column index
                $fc = PHPExcel_Cell::stringFromColumnIndex($fcIndex);
                $fc = '$' . $fc;
            } else {
                // column offset
                $fcIndex = ($fcIndex <= 127) ? $fcIndex : $fcIndex - 256;
                $fc = PHPExcel_Cell::stringFromColumnIndex($baseCol + $fcIndex);
            }

            // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
            if (!(0x8000 & self::_GetInt2d($subData, 4))) {
                // absolute row index
                $fr = $frIndex + 1;
                $fr = '$' . $fr;
            } else {
                // row offset
                $frIndex = ($frIndex <= 32767) ? $frIndex : $frIndex - 65536;
                $fr = $baseRow + $frIndex;
            }

        // offset: 6; size: 2; last column with relative/absolute flags

            // bit: 7-0; mask 0x00FF; column index
            $lcIndex = 0x00FF & self::_GetInt2d($subData, 6);
            $lcIndex = ($lcIndex <= 127) ? $lcIndex : $lcIndex - 256;
            $lc = PHPExcel_Cell::stringFromColumnIndex($baseCol + $lcIndex);

            // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
            if (!(0x4000 & self::_GetInt2d($subData, 6))) {
                // absolute column index
                $lc = PHPExcel_Cell::stringFromColumnIndex($lcIndex);
                $lc = '$' . $lc;
            } else {
                // column offset
                $lcIndex = ($lcIndex <= 127) ? $lcIndex : $lcIndex - 256;
                $lc = PHPExcel_Cell::stringFromColumnIndex($baseCol + $lcIndex);
            }

            // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
            if (!(0x8000 & self::_GetInt2d($subData, 6))) {
                // absolute row index
                $lr = $lrIndex + 1;
                $lr = '$' . $lr;
            } else {
                // row offset
                $lrIndex = ($lrIndex <= 32767) ? $lrIndex : $lrIndex - 65536;
                $lr = $baseRow + $lrIndex;
            }

        return "$fc$fr:$lc$lr";
    }

    /**
     * Read BIFF8 cell range address list
     * section 2.5.15
     *
     * @param string $subData
     * @return array
     */
    private function _readBIFF8CellRangeAddressList($subData)
    {
        $cellRangeAddresses = array();

        // offset: 0; size: 2; number of the following cell range addresses
        $nm = self::_GetInt2d($subData, 0);

        $offset = 2;
        // offset: 2; size: 8 * $nm; list of $nm (fixed) cell range addresses
        for ($i = 0; $i < $nm; ++$i) {
            $cellRangeAddresses[] = $this->_readBIFF8CellRangeAddressFixed(substr($subData, $offset, 8));
            $offset += 8;
        }

        return array(
            'size' => 2 + 8 * $nm,
            'cellRangeAddresses' => $cellRangeAddresses,
        );
    }

    /**
     * Read BIFF5 cell range address list
     * section 2.5.15
     *
     * @param string $subData
     * @return array
     */
    private function _readBIFF5CellRangeAddressList($subData)
    {
        $cellRangeAddresses = array();

        // offset: 0; size: 2; number of the following cell range addresses
        $nm = self::_GetInt2d($subData, 0);

        $offset = 2;
        // offset: 2; size: 6 * $nm; list of $nm (fixed) cell range addresses
        for ($i = 0; $i < $nm; ++$i) {
            $cellRangeAddresses[] = $this->_readBIFF5CellRangeAddressFixed(substr($subData, $offset, 6));
            $offset += 6;
        }

        return array(
            'size' => 2 + 6 * $nm,
            'cellRangeAddresses' => $cellRangeAddresses,
        );
    }

    /**
     * Get a sheet range like Sheet1:Sheet3 from REF index
     * Note: If there is only one sheet in the range, one gets e.g Sheet1
     * It can also happen that the REF structure uses the -1 (FFFF) code to indicate deleted sheets,
     * in which case an exception is thrown
     *
     * @param int $index
     * @return string|false
     * @throws Exception
     */
    private function _readSheetRangeByRefIndex($index)
    {
        if (isset($this->_ref[$index])) {

            $type = $this->_externalBooks[$this->_ref[$index]['externalBookIndex']]['type'];

            switch ($type) {
                case 'internal':
                    // check if we have a deleted 3d reference
                    if ($this->_ref[$index]['firstSheetIndex'] == 0xFFFF or $this->_ref[$index]['lastSheetIndex'] == 0xFFFF) {
                        throw new Exception('Deleted sheet reference');
                    }

                    // we have normal sheet range (collapsed or uncollapsed)
                    $firstSheetName = $this->_sheets[$this->_ref[$index]['firstSheetIndex']]['name'];
                    $lastSheetName = $this->_sheets[$this->_ref[$index]['lastSheetIndex']]['name'];

                    if ($firstSheetName == $lastSheetName) {
                        // collapsed sheet range
                        $sheetRange = $firstSheetName;
                    } else {
                        $sheetRange = "$firstSheetName:$lastSheetName";
                    }

                    // escape the single-quotes
                    $sheetRange = str_replace("'", "''", $sheetRange);

                    // if there are special characters, we need to enclose the range in single-quotes
                    // todo: check if we have identified the whole set of special characters
                    // it seems that the following characters are not accepted for sheet names
                    // and we may assume that they are not present: []*/:\?
                    if (preg_match("/[ !\"@#£$%&{()}<>=+'|^,;-]/", $sheetRange)) {
                        $sheetRange = "'$sheetRange'";
                    }

                    return $sheetRange;
                    break;

                default:
                    // TODO: external sheet support
                    throw new Exception('Excel5 reader only supports internal sheets in fomulas');
                    break;
            }
        }
        return false;
    }

    /**
     * read BIFF8 constant value array from array data
     * returns e.g. array('value' => '{1,2;3,4}', 'size' => 40}
     * section 2.5.8
     *
     * @param string $arrayData
     * @return array
     */
    private static function _readBIFF8ConstantArray($arrayData)
    {
        // offset: 0; size: 1; number of columns decreased by 1
        $nc = ord($arrayData[0]);

        // offset: 1; size: 2; number of rows decreased by 1
        $nr = self::_GetInt2d($arrayData, 1);
        $size = 3; // initialize
        $arrayData = substr($arrayData, 3);

        // offset: 3; size: var; list of ($nc + 1) * ($nr + 1) constant values
        $matrixChunks = array();
        for ($r = 1; $r <= $nr + 1; ++$r) {
            $items = array();
            for ($c = 1; $c <= $nc + 1; ++$c) {
                $constant = self::_readBIFF8Constant($arrayData);
                $items[] = $constant['value'];
                $arrayData = substr($arrayData, $constant['size']);
                $size += $constant['size'];
            }
            $matrixChunks[] = implode(',', $items); // looks like e.g. '1,"hello"'
        }
        $matrix = '{' . implode(';', $matrixChunks) . '}';

        return array(
            'value' => $matrix,
            'size' => $size,
        );
    }

    /**
     * read BIFF8 constant value which may be 'Empty Value', 'Number', 'String Value', 'Boolean Value', 'Error Value'
     * section 2.5.7
     * returns e.g. array('value' => '5', 'size' => 9)
     *
     * @param string $valueData
     * @return array
     */
    private static function _readBIFF8Constant($valueData)
    {
        // offset: 0; size: 1; identifier for type of constant
        $identifier = ord($valueData[0]);

        switch ($identifier) {
        case 0x00: // empty constant (what is this?)
            $value = '';
            $size = 9;
            break;
        case 0x01: // number
            // offset: 1; size: 8; IEEE 754 floating-point value
            $value = self::_extractNumber(substr($valueData, 1, 8));
            $size = 9;
            break;
        case 0x02: // string value
            // offset: 1; size: var; Unicode string, 16-bit string length
            $string = self::_readUnicodeStringLong(substr($valueData, 1));
            $value = '"' . $string['value'] . '"';
            $size = 1 + $string['size'];
            break;
        case 0x04: // boolean
            // offset: 1; size: 1; 0 = FALSE, 1 = TRUE
            if (ord($valueData[1])) {
                $value = 'TRUE';
            } else {
                $value = 'FALSE';
            }
            $size = 9;
            break;
        case 0x10: // error code
            // offset: 1; size: 1; error code
            $value = self::_mapErrorCode(ord($valueData[1]));
            $size = 9;
            break;
        }
        return array(
            'value' => $value,
            'size' => $size,
        );
    }

    /**
     * Extract RGB color
     * OpenOffice.org's Documentation of the Microsoft Excel File Format, section 2.5.4
     *
     * @param string $rgb Encoded RGB value (4 bytes)
     * @return array
     */
    private static function _readRGB($rgb)
    {
        // offset: 0; size 1; Red component
        $r = ord($rgb{0});

        // offset: 1; size: 1; Green component
        $g = ord($rgb{1});

        // offset: 2; size: 1; Blue component
        $b = ord($rgb{2});

        // HEX notation, e.g. 'FF00FC'
        $rgb = sprintf('%02X%02X%02X', $r, $g, $b);

        return array('rgb' => $rgb);
    }

    /**
     * Read byte string (8-bit string length)
     * OpenOffice documentation: 2.5.2
     *
     * @param string $subData
     * @return array
     */
    private function _readByteStringShort($subData)
    {
        // offset: 0; size: 1; length of the string (character count)
        $ln = ord($subData[0]);

        // offset: 1: size: var; character array (8-bit characters)
        $value = $this->_decodeCodepage(substr($subData, 1, $ln));

        return array(
            'value' => $value,
            'size' => 1 + $ln, // size in bytes of data structure
        );
    }

    /**
     * Read byte string (16-bit string length)
     * OpenOffice documentation: 2.5.2
     *
     * @param string $subData
     * @return array
     */
    private function _readByteStringLong($subData)
    {
        // offset: 0; size: 2; length of the string (character count)
        $ln = self::_GetInt2d($subData, 0);

        // offset: 2: size: var; character array (8-bit characters)
        $value = $this->_decodeCodepage(substr($subData, 2));

        //return $string;
        return array(
            'value' => $value,
            'size' => 2 + $ln, // size in bytes of data structure
        );
    }

    /**
     * Extracts an Excel Unicode short string (8-bit string length)
     * OpenOffice documentation: 2.5.3
     * function will automatically find out where the Unicode string ends.
     *
     * @param string $subData
     * @return array
     */
    private static function _readUnicodeStringShort($subData)
    {
        $value = '';

        // offset: 0: size: 1; length of the string (character count)
        $characterCount = ord($subData[0]);

        $string = self::_readUnicodeString(substr($subData, 1), $characterCount);

        // add 1 for the string length
        $string['size'] += 1;

        return $string;
    }

    /**
     * Extracts an Excel Unicode long string (16-bit string length)
     * OpenOffice documentation: 2.5.3
     * this function is under construction, needs to support rich text, and Asian phonetic settings
     *
     * @param string $subData
     * @return array
     */
    private static function _readUnicodeStringLong($subData)
    {
        $value = '';

        // offset: 0: size: 2; length of the string (character count)
        $characterCount = self::_GetInt2d($subData, 0);

        $string = self::_readUnicodeString(substr($subData, 2), $characterCount);

        // add 2 for the string length
        $string['size'] += 2;

        return $string;
    }

    /**
     * Read Unicode string with no string length field, but with known character count
     * this function is under construction, needs to support rich text, and Asian phonetic settings
     * OpenOffice.org's Documentation of the Microsoft Excel File Format, section 2.5.3
     *
     * @param string $subData
     * @param int $characterCount
     * @return array
     */
    private static function _readUnicodeString($subData, $characterCount)
    {
        $value = '';

        // offset: 0: size: 1; option flags

            // bit: 0; mask: 0x01; character compression (0 = compressed 8-bit, 1 = uncompressed 16-bit)
            $isCompressed = !((0x01 & ord($subData[0])) >> 0);

            // bit: 2; mask: 0x04; Asian phonetic settings
            $hasAsian = (0x04) & ord($subData[0]) >> 2;

            // bit: 3; mask: 0x08; Rich-Text settings
            $hasRichText = (0x08) & ord($subData[0]) >> 3;

        // offset: 1: size: var; character array
        // this offset assumes richtext and Asian phonetic settings are off which is generally wrong
        // needs to be fixed
        $value = self::_encodeUTF16(substr($subData, 1, $isCompressed ? $characterCount : 2 * $characterCount), $isCompressed);

        return array(
            'value' => $value,
            'size' => $isCompressed ? 1 + $characterCount : 1 + 2 * $characterCount, // the size in bytes including the option flags
        );
    }

    /**
     * Convert UTF-8 string to string surounded by double quotes. Used for explicit string tokens in formulas.
     * Example:  hello"world  -->  "hello""world"
     *
     * @param string $value UTF-8 encoded string
     * @return string
     */
    private static function _UTF8toExcelDoubleQuoted($value)
    {
        return '"' . str_replace('"', '""', $value) . '"';
    }

    /**
     * Reads first 8 bytes of a string and return IEEE 754 float
     *
     * @param string $data Binary string that is at least 8 bytes long
     * @return float
     */
    private static function _extractNumber($data)
    {
        $rknumhigh = self::_GetInt4d($data, 4);
        $rknumlow = self::_GetInt4d($data, 0);
        $sign = ($rknumhigh & 0x80000000) >> 31;
        $exp = (($rknumhigh & 0x7ff00000) >> 20) - 1023;
        $mantissa = (0x100000 | ($rknumhigh & 0x000fffff));
        $mantissalow1 = ($rknumlow & 0x80000000) >> 31;
        $mantissalow2 = ($rknumlow & 0x7fffffff);
        $value = $mantissa / pow( 2 , (20 - $exp));

        if ($mantissalow1 != 0) {
            $value += 1 / pow (2 , (21 - $exp));
        }

        $value += $mantissalow2 / pow (2 , (52 - $exp));
        if ($sign) {
            $value = -1 * $value;
        }

        return $value;
    }

    private static function _GetIEEE754($rknum)
    {
        if (($rknum & 0x02) != 0) {
            $value = $rknum >> 2;
        }
        else {
            // changes by mmp, info on IEEE754 encoding from
            // research.microsoft.com/~hollasch/cgindex/coding/ieeefloat.html
            // The RK format calls for using only the most significant 30 bits
            // of the 64 bit floating point value. The other 34 bits are assumed
            // to be 0 so we use the upper 30 bits of $rknum as follows...
            $sign = ($rknum & 0x80000000) >> 31;
            $exp = ($rknum & 0x7ff00000) >> 20;
            $mantissa = (0x100000 | ($rknum & 0x000ffffc));
            $value = $mantissa / pow( 2 , (20- ($exp - 1023)));
            if ($sign) {
                $value = -1 * $value;
            }
            //end of changes by mmp
        }
        if (($rknum & 0x01) != 0) {
            $value /= 100;
        }
        return $value;
    }

    /**
     * Get UTF-8 string from (compressed or uncompressed) UTF-16 string
     *
     * @param string $string
     * @param bool $compressed
     * @return string
     */
    private static function _encodeUTF16($string, $compressed = '')
    {
        if ($compressed) {
            $string = self::_uncompressByteString($string);
         }

        return PHPExcel_Shared_String::ConvertEncoding($string, 'UTF-8', 'UTF-16LE');
    }

    /**
     * Convert UTF-16 string in compressed notation to uncompressed form. Only used for BIFF8.
     *
     * @param string $string
     * @return string
     */
    private static function _uncompressByteString($string)
    {
        $uncompressedString = '';
        $strLen = strlen($string);
        for ($i = 0; $i < $strLen; ++$i) {
            $uncompressedString .= $string[$i] . "\0";
        }

        return $uncompressedString;
    }

    /**
     * Convert string to UTF-8. Only used for BIFF5.
     *
     * @param string $string
     * @return string
     */
    private function _decodeCodepage($string)
    {
        return PHPExcel_Shared_String::ConvertEncoding($string, 'UTF-8', $this->_codepage);
    }

    /**
     * Read 16-bit unsigned integer
     *
     * @param string $data
     * @param int $pos
     * @return int
     */
    public static function _GetInt2d($data, $pos)
    {
        return ord($data[$pos]) | (ord($data[$pos + 1]) << 8);
    }

    /**
     * Read 32-bit signed integer
     *
     * @param string $data
     * @param int $pos
     * @return int
     */
    public static function _GetInt4d($data, $pos)
    {
        // FIX: represent numbers correctly on 64-bit system
        // http://sourceforge.net/tracker/index.php?func=detail&aid=1487372&group_id=99160&atid=623334
        // Hacked by Andreas Rehm 2006 to ensure correct result of the <<24 block on 32 and 64bit systems
        $_or_24 = ord($data[$pos + 3]);
        if ($_or_24 >= 128) {
            // negative number
            $_ord_24 = -abs((256 - $_or_24) << 24);
        } else {
            $_ord_24 = ($_or_24 & 127) << 24;
        }
        return ord($data[$pos]) | (ord($data[$pos + 1]) << 8) | (ord($data[$pos + 2]) << 16) | $_ord_24;
    }

    /**
     * Read color
     *
     * @param int $color Indexed color
     * @param array $palette Color palette
     * @return array RGB color value, example: array('rgb' => 'FF0000')
     */
    private static function _readColor($color,$palette,$version)
    {
        if ($color <= 0x07 || $color >= 0x40) {
            // special built-in color
            return self::_mapBuiltInColor($color);
        } elseif (isset($palette) && isset($palette[$color - 8])) {
            // palette color, color index 0x08 maps to pallete index 0
            return $palette[$color - 8];
        } else {
            // default color table
            if ($version == self::XLS_BIFF8) {
                return self::_mapColor($color);
            } else {
                // BIFF5
                return self::_mapColorBIFF5($color);
            }
        }

        return $color;
    }


    /**
     * Map border style
     * OpenOffice documentation: 2.5.11
     *
     * @param int $index
     * @return string
     */
    private static function _mapBorderStyle($index)
    {
        switch ($index) {
            case 0x00: return PHPExcel_Style_Border::BORDER_NONE;
            case 0x01: return PHPExcel_Style_Border::BORDER_THIN;
            case 0x02: return PHPExcel_Style_Border::BORDER_MEDIUM;
            case 0x03: return PHPExcel_Style_Border::BORDER_DASHED;
            case 0x04: return PHPExcel_Style_Border::BORDER_DOTTED;
            case 0x05: return PHPExcel_Style_Border::BORDER_THICK;
            case 0x06: return PHPExcel_Style_Border::BORDER_DOUBLE;
            case 0x07: return PHPExcel_Style_Border::BORDER_HAIR;
            case 0x08: return PHPExcel_Style_Border::BORDER_MEDIUMDASHED;
            case 0x09: return PHPExcel_Style_Border::BORDER_DASHDOT;
            case 0x0A: return PHPExcel_Style_Border::BORDER_MEDIUMDASHDOT;
            case 0x0B: return PHPExcel_Style_Border::BORDER_DASHDOTDOT;
            case 0x0C: return PHPExcel_Style_Border::BORDER_MEDIUMDASHDOTDOT;
            case 0x0D: return PHPExcel_Style_Border::BORDER_SLANTDASHDOT;
            default:   return PHPExcel_Style_Border::BORDER_NONE;
        }
    }

    /**
     * Get fill pattern from index
     * OpenOffice documentation: 2.5.12
     *
     * @param int $index
     * @return string
     */
    private static function _mapFillPattern($index)
    {
        switch ($index) {
            case 0x00: return PHPExcel_Style_Fill::FILL_NONE;
            case 0x01: return PHPExcel_Style_Fill::FILL_SOLID;
            case 0x02: return PHPExcel_Style_Fill::FILL_PATTERN_MEDIUMGRAY;
            case 0x03: return PHPExcel_Style_Fill::FILL_PATTERN_DARKGRAY;
            case 0x04: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRAY;
            case 0x05: return PHPExcel_Style_Fill::FILL_PATTERN_DARKHORIZONTAL;
            case 0x06: return PHPExcel_Style_Fill::FILL_PATTERN_DARKVERTICAL;
            case 0x07: return PHPExcel_Style_Fill::FILL_PATTERN_DARKDOWN;
            case 0x08: return PHPExcel_Style_Fill::FILL_PATTERN_DARKUP;
            case 0x09: return PHPExcel_Style_Fill::FILL_PATTERN_DARKGRID;
            case 0x0A: return PHPExcel_Style_Fill::FILL_PATTERN_DARKTRELLIS;
            case 0x0B: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTHORIZONTAL;
            case 0x0C: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTVERTICAL;
            case 0x0D: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTDOWN;
            case 0x0E: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTUP;
            case 0x0F: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRID;
            case 0x10: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTTRELLIS;
            case 0x11: return PHPExcel_Style_Fill::FILL_PATTERN_GRAY125;
            case 0x12: return PHPExcel_Style_Fill::FILL_PATTERN_GRAY0625;
            default:   return PHPExcel_Style_Fill::FILL_NONE;
        }
    }

    /**
     * Map error code, e.g. '#N/A'
     *
     * @param int $subData
     * @return string
     */
    private static function _mapErrorCode($subData)
    {
        switch ($subData) {
            case 0x00: return '#NULL!';        break;
            case 0x07: return '#DIV/0!';    break;
            case 0x0F: return '#VALUE!';    break;
            case 0x17: return '#REF!';        break;
            case 0x1D: return '#NAME?';        break;
            case 0x24: return '#NUM!';        break;
            case 0x2A: return '#N/A';        break;
            default: return false;
        }
    }

    /**
     * Map built-in color to RGB value
     *
     * @param int $color Indexed color
     * @return array
     */
    private static function _mapBuiltInColor($color)
    {
        switch ($color) {
            case 0x00: return array('rgb' => '000000');
            case 0x01: return array('rgb' => 'FFFFFF');
            case 0x02: return array('rgb' => 'FF0000');
            case 0x03: return array('rgb' => '00FF00');
            case 0x04: return array('rgb' => '0000FF');
            case 0x05: return array('rgb' => 'FFFF00');
            case 0x06: return array('rgb' => 'FF00FF');
            case 0x07: return array('rgb' => '00FFFF');
            case 0x40: return array('rgb' => '000000'); // system window text color
            case 0x41: return array('rgb' => 'FFFFFF'); // system window background color
            default:   return array('rgb' => '000000');
        }
    }

    /**
     * Map color array from BIFF5 built-in color index
     *
     * @param int $subData
     * @return array
     */
    private static function _mapColorBIFF5($subData)
    {
        switch ($subData) {
            case 0x08: return array('rgb' => '000000');
            case 0x09: return array('rgb' => 'FFFFFF');
            case 0x0A: return array('rgb' => 'FF0000');
            case 0x0B: return array('rgb' => '00FF00');
            case 0x0C: return array('rgb' => '0000FF');
            case 0x0D: return array('rgb' => 'FFFF00');
            case 0x0E: return array('rgb' => 'FF00FF');
            case 0x0F: return array('rgb' => '00FFFF');
            case 0x10: return array('rgb' => '800000');
            case 0x11: return array('rgb' => '008000');
            case 0x12: return array('rgb' => '000080');
            case 0x13: return array('rgb' => '808000');
            case 0x14: return array('rgb' => '800080');
            case 0x15: return array('rgb' => '008080');
            case 0x16: return array('rgb' => 'C0C0C0');
            case 0x17: return array('rgb' => '808080');
            case 0x18: return array('rgb' => '8080FF');
            case 0x19: return array('rgb' => '802060');
            case 0x1A: return array('rgb' => 'FFFFC0');
            case 0x1B: return array('rgb' => 'A0E0F0');
            case 0x1C: return array('rgb' => '600080');
            case 0x1D: return array('rgb' => 'FF8080');
            case 0x1E: return array('rgb' => '0080C0');
            case 0x1F: return array('rgb' => 'C0C0FF');
            case 0x20: return array('rgb' => '000080');
            case 0x21: return array('rgb' => 'FF00FF');
            case 0x22: return array('rgb' => 'FFFF00');
            case 0x23: return array('rgb' => '00FFFF');
            case 0x24: return array('rgb' => '800080');
            case 0x25: return array('rgb' => '800000');
            case 0x26: return array('rgb' => '008080');
            case 0x27: return array('rgb' => '0000FF');
            case 0x28: return array('rgb' => '00CFFF');
            case 0x29: return array('rgb' => '69FFFF');
            case 0x2A: return array('rgb' => 'E0FFE0');
            case 0x2B: return array('rgb' => 'FFFF80');
            case 0x2C: return array('rgb' => 'A6CAF0');
            case 0x2D: return array('rgb' => 'DD9CB3');
            case 0x2E: return array('rgb' => 'B38FEE');
            case 0x2F: return array('rgb' => 'E3E3E3');
            case 0x30: return array('rgb' => '2A6FF9');
            case 0x31: return array('rgb' => '3FB8CD');
            case 0x32: return array('rgb' => '488436');
            case 0x33: return array('rgb' => '958C41');
            case 0x34: return array('rgb' => '8E5E42');
            case 0x35: return array('rgb' => 'A0627A');
            case 0x36: return array('rgb' => '624FAC');
            case 0x37: return array('rgb' => '969696');
            case 0x38: return array('rgb' => '1D2FBE');
            case 0x39: return array('rgb' => '286676');
            case 0x3A: return array('rgb' => '004500');
            case 0x3B: return array('rgb' => '453E01');
            case 0x3C: return array('rgb' => '6A2813');
            case 0x3D: return array('rgb' => '85396A');
            case 0x3E: return array('rgb' => '4A3285');
            case 0x3F: return array('rgb' => '424242');
            default:   return array('rgb' => '000000');
        }
    }

    /**
     * Map color array from BIFF8 built-in color index
     *
     * @param int $subData
     * @return array
     */
    private static function _mapColor($subData)
    {
        switch ($subData) {
            case 0x08: return array('rgb' => '000000');
            case 0x09: return array('rgb' => 'FFFFFF');
            case 0x0A: return array('rgb' => 'FF0000');
            case 0x0B: return array('rgb' => '00FF00');
            case 0x0C: return array('rgb' => '0000FF');
            case 0x0D: return array('rgb' => 'FFFF00');
            case 0x0E: return array('rgb' => 'FF00FF');
            case 0x0F: return array('rgb' => '00FFFF');
            case 0x10: return array('rgb' => '800000');
            case 0x11: return array('rgb' => '008000');
            case 0x12: return array('rgb' => '000080');
            case 0x13: return array('rgb' => '808000');
            case 0x14: return array('rgb' => '800080');
            case 0x15: return array('rgb' => '008080');
            case 0x16: return array('rgb' => 'C0C0C0');
            case 0x17: return array('rgb' => '808080');
            case 0x18: return array('rgb' => '9999FF');
            case 0x19: return array('rgb' => '993366');
            case 0x1A: return array('rgb' => 'FFFFCC');
            case 0x1B: return array('rgb' => 'CCFFFF');
            case 0x1C: return array('rgb' => '660066');
            case 0x1D: return array('rgb' => 'FF8080');
            case 0x1E: return array('rgb' => '0066CC');
            case 0x1F: return array('rgb' => 'CCCCFF');
            case 0x20: return array('rgb' => '000080');
            case 0x21: return array('rgb' => 'FF00FF');
            case 0x22: return array('rgb' => 'FFFF00');
            case 0x23: return array('rgb' => '00FFFF');
            case 0x24: return array('rgb' => '800080');
            case 0x25: return array('rgb' => '800000');
            case 0x26: return array('rgb' => '008080');
            case 0x27: return array('rgb' => '0000FF');
            case 0x28: return array('rgb' => '00CCFF');
            case 0x29: return array('rgb' => 'CCFFFF');
            case 0x2A: return array('rgb' => 'CCFFCC');
            case 0x2B: return array('rgb' => 'FFFF99');
            case 0x2C: return array('rgb' => '99CCFF');
            case 0x2D: return array('rgb' => 'FF99CC');
            case 0x2E: return array('rgb' => 'CC99FF');
            case 0x2F: return array('rgb' => 'FFCC99');
            case 0x30: return array('rgb' => '3366FF');
            case 0x31: return array('rgb' => '33CCCC');
            case 0x32: return array('rgb' => '99CC00');
            case 0x33: return array('rgb' => 'FFCC00');
            case 0x34: return array('rgb' => 'FF9900');
            case 0x35: return array('rgb' => 'FF6600');
            case 0x36: return array('rgb' => '666699');
            case 0x37: return array('rgb' => '969696');
            case 0x38: return array('rgb' => '003366');
            case 0x39: return array('rgb' => '339966');
            case 0x3A: return array('rgb' => '003300');
            case 0x3B: return array('rgb' => '333300');
            case 0x3C: return array('rgb' => '993300');
            case 0x3D: return array('rgb' => '993366');
            case 0x3E: return array('rgb' => '333399');
            case 0x3F: return array('rgb' => '333333');
            default:   return array('rgb' => '000000');
        }
    }

    private function _parseRichText($is = '') {
        $value = new PHPExcel_RichText();

        $value->createText($is);

        return $value;
    }

}
